diff --git a/.github/workflows/bump-major-version.yaml b/.github/workflows/bump-major-version.yaml index b39d74d704044..7a6bc4bdb6d87 100644 --- a/.github/workflows/bump-major-version.yaml +++ b/.github/workflows/bump-major-version.yaml @@ -50,7 +50,7 @@ jobs: run: | # We need to vendor go modules for codegen yet go mod download - go mod vendor -v + go work vendor -v working-directory: /home/runner/go/src/github.com/argoproj/argo-cd - name: Install toolchain for codegen run: | diff --git a/.github/workflows/ci-build.yaml b/.github/workflows/ci-build.yaml index e6cdff46d6c4b..37bd9497714d4 100644 --- a/.github/workflows/ci-build.yaml +++ b/.github/workflows/ci-build.yaml @@ -65,6 +65,9 @@ jobs: go mod download - name: Check for tidiness of go.mod and go.sum run: | + rm go.work.sum + go work sync + go work vendor go mod tidy git diff --exit-code -- . @@ -270,7 +273,7 @@ jobs: run: | # We need to vendor go modules for codegen yet go mod download - go mod vendor -v + go work vendor -v working-directory: /home/runner/go/src/github.com/argoproj/argo-cd - name: Install toolchain for codegen run: | @@ -291,7 +294,7 @@ jobs: - name: Check nothing has changed run: | set -xo pipefail - git diff --exit-code -- . ':!go.sum' ':!go.mod' ':!assets/swagger.json' | tee codegen.patch + git diff --exit-code -- . ':!go.sum' ':!go.mod' ':!assets/swagger.json' ':!go.work' ':!go.work.sum' | tee codegen.patch working-directory: /home/runner/go/src/github.com/argoproj/argo-cd build-ui: diff --git a/Dockerfile b/Dockerfile index eeac0e40d900c..b70685dbab1fb 100644 --- a/Dockerfile +++ b/Dockerfile @@ -108,6 +108,8 @@ FROM --platform=$BUILDPLATFORM docker.io/library/golang:1.25.1@sha256:8305f5fa8e WORKDIR /go/src/github.com/argoproj/argo-cd COPY go.* ./ +RUN mkdir -p gitops-engine +COPY gitops-engine/go.* ./gitops-engine RUN go mod download # Perform the build diff --git a/Makefile b/Makefile index ba1195e183353..150be9c41e947 100644 --- a/Makefile +++ b/Makefile @@ -373,11 +373,11 @@ mod-download-local: .PHONY: mod-vendor mod-vendor: test-tools-image - $(call run-in-test-client,go mod vendor) + $(call run-in-test-client,go work vendor) .PHONY: mod-vendor-local mod-vendor-local: mod-download-local - go mod vendor + go work vendor # Run linter on the code .PHONY: lint diff --git a/Tiltfile b/Tiltfile index dcc784e84f1d5..0d30e1d45ca37 100644 --- a/Tiltfile +++ b/Tiltfile @@ -282,7 +282,7 @@ local_resource( local_resource( 'vendor', - 'go mod vendor', + 'go work vendor', deps = [ 'go.mod', 'go.sum', diff --git a/gitops-engine/Dockerfile b/gitops-engine/Dockerfile new file mode 100644 index 0000000000000..64208ef0fe7b5 --- /dev/null +++ b/gitops-engine/Dockerfile @@ -0,0 +1,16 @@ +FROM golang:1.22 AS builder + +WORKDIR /src + +COPY go.mod /src/go.mod +COPY go.sum /src/go.sum + +RUN go mod download + +# Perform the build +COPY . . +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o /dist/gitops ./agent + + +FROM alpine/git:v2.45.2 +COPY --from=builder /dist/gitops /usr/local/bin/gitops diff --git a/gitops-engine/LICENSE b/gitops-engine/LICENSE new file mode 100644 index 0000000000000..67e99b065bcd6 --- /dev/null +++ b/gitops-engine/LICENSE @@ -0,0 +1,202 @@ + + 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 2017-2018 The Argo 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. diff --git a/gitops-engine/Makefile b/gitops-engine/Makefile new file mode 100644 index 0000000000000..8c31d4351ab43 --- /dev/null +++ b/gitops-engine/Makefile @@ -0,0 +1,32 @@ +# docker image publishing options +DOCKER_PUSH?=false +IMAGE_NAMESPACE?= +IMAGE_TAG?=latest +ifdef IMAGE_NAMESPACE +IMAGE_PREFIX=${IMAGE_NAMESPACE}/ +endif + +.PHONY: generate +generate: agent-manifests + +.PHONY: test +test: + go test -race ./... -coverprofile=coverage.out + +.PHONY: lint +lint: + golangci-lint run + +.PHONY: agent-image +agent-image: + docker build -t $(IMAGE_PREFIX)gitops-agent . -f Dockerfile + @if [ "$(DOCKER_PUSH)" = "true" ] ; then docker push $(IMAGE_PREFIX)gitops-agent:$(IMAGE_TAG) ; fi + +.PHONY: agent-manifests +agent-manifests: + kustomize build ./agent/manifests/cluster-install > ./agent/manifests/install.yaml + kustomize build ./agent/manifests/namespace-install > ./agent/manifests/install-namespaced.yaml + +.PHONY: generate-mocks +generate-mocks: + go generate -x -v "github.com/argoproj/gitops-engine/pkg/utils/tracing/tracer_testing" diff --git a/gitops-engine/OWNERS b/gitops-engine/OWNERS new file mode 100644 index 0000000000000..1872ed23c0f2d --- /dev/null +++ b/gitops-engine/OWNERS @@ -0,0 +1,14 @@ +owners: +- alexmt +- jessesuen + +approvers: +- alexec +- alexmt +- jannfis +- jessesuen +- mayzhang2000 + +reviewers: +- ash2k +- dthomson25 diff --git a/gitops-engine/README.md b/gitops-engine/README.md new file mode 100644 index 0000000000000..cf39095bbef0e --- /dev/null +++ b/gitops-engine/README.md @@ -0,0 +1,52 @@ +# Ongoing migration +The gitops-engine repository is migrating to https://github.com/argoproj/argo-cd. + +As part of this migration, we are going to: + +- close PRs with no updates older than 1 year +- ask ppl to update the remaining PRs that had some update in the last year but are outdated. +- review the pending recent open PRs that we deem important + +Hold on your PRs until the migration is complete. + +# GitOps Engine + +Various GitOps operators address different use-cases and provide different user experiences but all have similar set of core features. The team behind +[Argo CD](https://github.com/argoproj/argo-cd) has implemented a reusable library that implements core GitOps features: + +- Kubernetes resource cache ✅ +- Resources reconciliation ✅ +- Sync Planning ✅ +- Access to Git repositories +- Manifest Generation + +## Proposals, specifications and ideas + +Do you want to propose one more feature and want to enhance the existing one? +Proposals and ideas are in markdown docs in the [`specs/`](specs/) directory. +To create a new proposal, simply copy the spec [`template`](specs/template.md), +name the file corresponding to the title of your proposal, and place it in the +`specs/` directory. + +A good starting point to understand the structure is the [GitOps Engine Design spec](specs/design.md). + +We tried to answer frequently asked question in a [separate FAQ document](docs/faq.md). + +## Governance + +This project is licensed under the [Apache 2 license](LICENSE). + +The GitOps Engine follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/master/code-of-conduct.md). + +## Get involved + +If you are as excited about GitOps and one common engine for it as much as we are, please get in touch. If you want to write code that's great, if you want to share feedback, ideas and use-cases, that's great too. + +Find us on the [#argo-cd-contributors][argo-cd-contributors-slack] on CNCF Slack (get an [invite here][cncf-slack]). + +[argo-cd-contributors-slack]: https://cloud-native.slack.com/archives/C020XM04CUW +[cncf-slack]: https://slack.cncf.io/ + +### Contributing to the effort + +At this stage we are interested in feedback, use-cases and help on the GitOps Engine. diff --git a/gitops-engine/agent/README.md b/gitops-engine/agent/README.md new file mode 100644 index 0000000000000..fbf4f78421aa3 --- /dev/null +++ b/gitops-engine/agent/README.md @@ -0,0 +1,76 @@ +# GitOps Agent + +The GitOps Agent leverages the GitOps Engine and provides access to many engine features via a simple CLI interface. +The agent provides the same set of core features as Argo CD including basic reconciliation, syncing as well as sync hooks and sync waves. + +The main difference is that the agent is syncing one Git repository into the same cluster where it is installed. + +## Quick Start + +By default, the agent is configured to use manifests from [guestbook](https://github.com/argoproj/argocd-example-apps/tree/master/guestbook) +directory in https://github.com/argoproj/argocd-example-apps repository. + +The agent supports two modes: + +* namespaced mode - agent manages the same namespace where it is installed +* full cluster mode - agent manages the whole cluster + +### Namespaced Mode + +Install the agent with the default settings using the command below. Done! + +```bash +kubectl apply -f https://raw.githubusercontent.com/argoproj/gitops-engine/master/agent/manifests/install-namespaced.yaml +kubectl rollout status deploy/gitops-agent +``` + +The agent logs: + +```bash +kubectl logs -f deploy/gitops-agent gitops-agent +``` + +Find the guestbook deployment in the current K8S namespace: + +```bash +kubectl get deployment +``` + +### Cluster Mode + +The cluster mode grants full cluster access to the GitOps Agent. Use the following command to install an agent into the +`gitops-agent` namespace and use it to manage resources in any cluster namespace. + +> Note. In cluster mode agents gets **full** cluster access. +> See [gitops-agent-cluster-role.yaml](./manifests/cluster-install/gitops-agent-cluster-role.yaml) definition for more information. + +```bash +kubectl create ns gitops-agent +kubectl apply -f https://raw.githubusercontent.com/argoproj/gitops-engine/master/agent/manifests/install.yaml -n gitops-agent +``` + +### Customize Git Repository + +The agent runs [git-sync](https://github.com/kubernetes/git-sync) as a sidecar container to access the repository. +Update the container env [variables](https://github.com/kubernetes/git-sync#parameters) to change the repository. + +### Demo Recording + +[![asciicast](https://asciinema.org/a/FWbvVAiSsiI87wQx2TJbRMlxN.svg)](https://asciinema.org/a/FWbvVAiSsiI87wQx2TJbRMlxN) + + +### Profiling + +Using env variables to enable profiling mode, the agent can be started with the following envs: + +```bash +export GITOPS_ENGINE_PROFILE=web +# optional, default pprofile address is 127.0.0.1:6060 +export GITOPS_ENGINE_PROFILE_HOST=127.0.0.1 +export GITOPS_ENGINE_PROFILE_PORT=6060 +``` + +And then you can open profile in the browser(or using [pprof](https://github.com/google/pprof) cmd to generate diagrams): + +- http://127.0.0.1:6060/debug/pprof/goroutine?debug=2 +- http://127.0.0.1:6060/debug/pprof/mutex?debug=2 diff --git a/gitops-engine/agent/main.go b/gitops-engine/agent/main.go new file mode 100644 index 0000000000000..b325e9414300e --- /dev/null +++ b/gitops-engine/agent/main.go @@ -0,0 +1,239 @@ +package main + +import ( + "context" + "crypto/sha256" + "encoding/base64" + "fmt" + "net/http" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" + "text/tabwriter" + "time" + + "github.com/argoproj/gitops-engine/pkg/utils/text" + + "github.com/go-logr/logr" + "github.com/spf13/cobra" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/tools/clientcmd" + "k8s.io/klog/v2/textlogger" + + "github.com/argoproj/gitops-engine/pkg/cache" + "github.com/argoproj/gitops-engine/pkg/engine" + "github.com/argoproj/gitops-engine/pkg/sync" + "github.com/argoproj/gitops-engine/pkg/utils/kube" + + _ "net/http/pprof" +) + +const ( + annotationGCMark = "gitops-agent.argoproj.io/gc-mark" + envProfile = "GITOPS_ENGINE_PROFILE" + envProfileHost = "GITOPS_ENGINE_PROFILE_HOST" + envProfilePort = "GITOPS_ENGINE_PROFILE_PORT" +) + +func main() { + log := textlogger.NewLogger(textlogger.NewConfig()) + err := newCmd(log).Execute() + checkError(err, log) +} + +type resourceInfo struct { + gcMark string +} + +type settings struct { + repoPath string + paths []string +} + +func (s *settings) getGCMark(key kube.ResourceKey) string { + h := sha256.New() + _, _ = fmt.Fprintf(h, "%s/%s", s.repoPath, strings.Join(s.paths, ",")) + _, _ = h.Write([]byte(strings.Join([]string{key.Group, key.Kind, key.Name}, "/"))) + return "sha256." + base64.RawURLEncoding.EncodeToString(h.Sum(nil)) +} + +func (s *settings) parseManifests() ([]*unstructured.Unstructured, string, error) { + cmd := exec.Command("git", "rev-parse", "HEAD") + cmd.Dir = s.repoPath + revision, err := cmd.CombinedOutput() + if err != nil { + return nil, "", fmt.Errorf("failed to determine git revision: %w", err) + } + var res []*unstructured.Unstructured + for i := range s.paths { + if err := filepath.Walk(filepath.Join(s.repoPath, s.paths[i]), func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + if ext := strings.ToLower(filepath.Ext(info.Name())); ext != ".json" && ext != ".yml" && ext != ".yaml" { + return nil + } + data, err := os.ReadFile(path) + if err != nil { + return fmt.Errorf("failed to read file %s: %w", path, err) + } + items, err := kube.SplitYAML(data) + if err != nil { + return fmt.Errorf("failed to parse %s: %w", path, err) + } + res = append(res, items...) + return nil + }); err != nil { + return nil, "", fmt.Errorf("failed to parse %s: %w", s.paths[i], err) + } + } + for i := range res { + annotations := res[i].GetAnnotations() + if annotations == nil { + annotations = make(map[string]string) + } + annotations[annotationGCMark] = s.getGCMark(kube.GetResourceKey(res[i])) + res[i].SetAnnotations(annotations) + } + return res, string(revision), nil +} + +func StartProfiler(log logr.Logger) { + if os.Getenv(envProfile) == "web" { + go func() { + runtime.SetBlockProfileRate(1) + runtime.SetMutexProfileFraction(1) + profilePort := text.WithDefault(os.Getenv(envProfilePort), "6060") + profileHost := text.WithDefault(os.Getenv(envProfileHost), "127.0.0.1") + + log.Info("pprof", "err", http.ListenAndServe(fmt.Sprintf("%s:%s", profileHost, profilePort), nil)) + }() + } +} + +func newCmd(log logr.Logger) *cobra.Command { + var ( + clientConfig clientcmd.ClientConfig + paths []string + resyncSeconds int + port int + prune bool + namespace string + namespaced bool + ) + cmd := cobra.Command{ + Use: "gitops REPO_PATH", + Run: func(cmd *cobra.Command, args []string) { + if len(args) < 1 { + cmd.HelpFunc()(cmd, args) + os.Exit(1) + } + s := settings{args[0], paths} + config, err := clientConfig.ClientConfig() + checkError(err, log) + if namespace == "" { + namespace, _, err = clientConfig.Namespace() + checkError(err, log) + } + + var namespaces []string + if namespaced { + namespaces = []string{namespace} + } + + StartProfiler(log) + clusterCache := cache.NewClusterCache(config, + cache.SetNamespaces(namespaces), + cache.SetLogr(log), + cache.SetPopulateResourceInfoHandler(func(un *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + // store gc mark of every resource + gcMark := un.GetAnnotations()[annotationGCMark] + info = &resourceInfo{gcMark: un.GetAnnotations()[annotationGCMark]} + // cache resources that has that mark to improve performance + cacheManifest = gcMark != "" + return + }), + ) + gitOpsEngine := engine.NewEngine(config, clusterCache, engine.WithLogr(log)) + checkError(err, log) + + cleanup, err := gitOpsEngine.Run() + checkError(err, log) + defer cleanup() + + resync := make(chan bool) + go func() { + ticker := time.NewTicker(time.Second * time.Duration(resyncSeconds)) + for { + <-ticker.C + log.Info("Synchronization triggered by timer") + resync <- true + } + }() + http.HandleFunc("/api/v1/sync", func(_ http.ResponseWriter, _ *http.Request) { + log.Info("Synchronization triggered by API call") + resync <- true + }) + go func() { + checkError(http.ListenAndServe(fmt.Sprintf("0.0.0.0:%d", port), nil), log) + }() + + for ; true; <-resync { + target, revision, err := s.parseManifests() + if err != nil { + log.Error(err, "Failed to parse target state") + continue + } + + result, err := gitOpsEngine.Sync(context.Background(), target, func(r *cache.Resource) bool { + return r.Info.(*resourceInfo).gcMark == s.getGCMark(r.ResourceKey()) + }, revision, namespace, sync.WithPrune(prune), sync.WithLogr(log)) + if err != nil { + log.Error(err, "Failed to synchronize cluster state") + continue + } + w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) + _, _ = fmt.Fprintf(w, "RESOURCE\tRESULT\n") + for _, res := range result { + _, _ = fmt.Fprintf(w, "%s\t%s\n", res.ResourceKey.String(), res.Message) + } + _ = w.Flush() + } + }, + } + clientConfig = addKubectlFlagsToCmd(&cmd) + cmd.Flags().StringArrayVar(&paths, "path", []string{"."}, "Directory path with-in repository") + cmd.Flags().IntVar(&resyncSeconds, "resync-seconds", 300, "Resync duration in seconds.") + cmd.Flags().IntVar(&port, "port", 9001, "Port number.") + cmd.Flags().BoolVar(&prune, "prune", true, "Enables resource pruning.") + cmd.Flags().BoolVar(&namespaced, "namespaced", false, "Switches agent into namespaced mode.") + cmd.Flags().StringVar(&namespace, "default-namespace", "", + "The namespace that should be used if resource namespace is not specified. "+ + "By default resources are installed into the same namespace where gitops-agent is installed.") + return &cmd +} + +// addKubectlFlagsToCmd adds kubectl like flags to a command and returns the ClientConfig interface +// for retrieving the values. +func addKubectlFlagsToCmd(cmd *cobra.Command) clientcmd.ClientConfig { + loadingRules := clientcmd.NewDefaultClientConfigLoadingRules() + loadingRules.DefaultClientConfig = &clientcmd.DefaultClientConfig + overrides := clientcmd.ConfigOverrides{} + kflags := clientcmd.RecommendedConfigOverrideFlags("") + cmd.PersistentFlags().StringVar(&loadingRules.ExplicitPath, "kubeconfig", "", "Path to a kube config. Only required if out-of-cluster") + clientcmd.BindOverrideFlags(&overrides, cmd.PersistentFlags(), kflags) + return clientcmd.NewInteractiveDeferredLoadingClientConfig(loadingRules, &overrides, os.Stdin) +} + +// checkError is a convenience function to check if an error is non-nil and exit if it was +func checkError(err error, log logr.Logger) { + if err != nil { + log.Error(err, "Fatal error") + os.Exit(1) + } +} diff --git a/gitops-engine/agent/manifests/base/gitops-agent-deploy.yaml b/gitops-engine/agent/manifests/base/gitops-agent-deploy.yaml new file mode 100644 index 0000000000000..4cd077dafcfd6 --- /dev/null +++ b/gitops-engine/agent/manifests/base/gitops-agent-deploy.yaml @@ -0,0 +1,47 @@ +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: gitops-agent +spec: + strategy: + type: Recreate + selector: + matchLabels: + app.kubernetes.io/name: gitops-agent + template: + metadata: + labels: + app.kubernetes.io/name: gitops-agent + spec: + containers: + - name: gitops-agent + command: + - gitops + - /tmp/git/repo + - --path + - guestbook + image: argoproj/gitops-agent:latest + volumeMounts: + - name: git + mountPath: /tmp/git + + - name: git-sync + env: + - name: GIT_SYNC_REPO + value: https://github.com/argoproj/argocd-example-apps + args: + - --webhook-url + - http://localhost:9001/api/v1/sync + - --dest + - repo + image: k8s.gcr.io/git-sync:v3.1.6 + volumeMounts: + - name: git + mountPath: /tmp/git + + serviceAccountName: gitops-agent + + volumes: + - emptyDir: {} + name: git \ No newline at end of file diff --git a/gitops-engine/agent/manifests/base/gitops-agent-sa.yaml b/gitops-engine/agent/manifests/base/gitops-agent-sa.yaml new file mode 100644 index 0000000000000..4e2523391128c --- /dev/null +++ b/gitops-engine/agent/manifests/base/gitops-agent-sa.yaml @@ -0,0 +1,5 @@ +--- +apiVersion: v1 +kind: ServiceAccount +metadata: + name: gitops-agent diff --git a/gitops-engine/agent/manifests/base/kustomization.yaml b/gitops-engine/agent/manifests/base/kustomization.yaml new file mode 100644 index 0000000000000..c9e64c0f14aee --- /dev/null +++ b/gitops-engine/agent/manifests/base/kustomization.yaml @@ -0,0 +1,6 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +resources: +- ./gitops-agent-deploy.yaml +- ./gitops-agent-sa.yaml diff --git a/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role-binding.yaml b/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role-binding.yaml new file mode 100644 index 0000000000000..45355f758f664 --- /dev/null +++ b/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role-binding.yaml @@ -0,0 +1,13 @@ +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: gitops-agent +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: gitops-agent +subjects: + - kind: ServiceAccount + name: gitops-agent + namespace: gitops-agent diff --git a/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role.yaml b/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role.yaml new file mode 100644 index 0000000000000..cfdeef711bebe --- /dev/null +++ b/gitops-engine/agent/manifests/cluster-install/gitops-agent-cluster-role.yaml @@ -0,0 +1,16 @@ +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: gitops-agent +rules: + - apiGroups: + - '*' + resources: + - '*' + verbs: + - '*' + - nonResourceURLs: + - '*' + verbs: + - '*' diff --git a/gitops-engine/agent/manifests/cluster-install/kustomization.yaml b/gitops-engine/agent/manifests/cluster-install/kustomization.yaml new file mode 100644 index 0000000000000..c7484f2668a1e --- /dev/null +++ b/gitops-engine/agent/manifests/cluster-install/kustomization.yaml @@ -0,0 +1,9 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +bases: +- ../base + +resources: +- ./gitops-agent-cluster-role-binding.yaml +- ./gitops-agent-cluster-role.yaml diff --git a/gitops-engine/agent/manifests/install-namespaced.yaml b/gitops-engine/agent/manifests/install-namespaced.yaml new file mode 100644 index 0000000000000..856366165f258 --- /dev/null +++ b/gitops-engine/agent/manifests/install-namespaced.yaml @@ -0,0 +1,73 @@ +apiVersion: v1 +kind: ServiceAccount +metadata: + name: gitops-agent +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: gitops-agent +rules: +- apiGroups: + - '*' + resources: + - '*' + verbs: + - '*' +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: gitops-agent +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: gitops-agent +subjects: +- kind: ServiceAccount + name: gitops-agent +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: gitops-agent +spec: + selector: + matchLabels: + app.kubernetes.io/name: gitops-agent + strategy: + type: Recreate + template: + metadata: + labels: + app.kubernetes.io/name: gitops-agent + spec: + containers: + - command: + - gitops + - /tmp/git/repo + - --path + - guestbook + - --namespaced + image: argoproj/gitops-agent:latest + name: gitops-agent + volumeMounts: + - mountPath: /tmp/git + name: git + - args: + - --webhook-url + - http://localhost:9001/api/v1/sync + - --dest + - repo + env: + - name: GIT_SYNC_REPO + value: https://github.com/argoproj/argocd-example-apps + image: k8s.gcr.io/git-sync:v3.1.6 + name: git-sync + volumeMounts: + - mountPath: /tmp/git + name: git + serviceAccountName: gitops-agent + volumes: + - emptyDir: {} + name: git diff --git a/gitops-engine/agent/manifests/install.yaml b/gitops-engine/agent/manifests/install.yaml new file mode 100644 index 0000000000000..5cb0e276960be --- /dev/null +++ b/gitops-engine/agent/manifests/install.yaml @@ -0,0 +1,77 @@ +apiVersion: v1 +kind: ServiceAccount +metadata: + name: gitops-agent +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: gitops-agent +rules: +- apiGroups: + - '*' + resources: + - '*' + verbs: + - '*' +- nonResourceURLs: + - '*' + verbs: + - '*' +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: gitops-agent +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: gitops-agent +subjects: +- kind: ServiceAccount + name: gitops-agent + namespace: gitops-agent +--- +apiVersion: apps/v1 +kind: Deployment +metadata: + name: gitops-agent +spec: + selector: + matchLabels: + app.kubernetes.io/name: gitops-agent + strategy: + type: Recreate + template: + metadata: + labels: + app.kubernetes.io/name: gitops-agent + spec: + containers: + - command: + - gitops + - /tmp/git/repo + - --path + - guestbook + image: argoproj/gitops-agent:latest + name: gitops-agent + volumeMounts: + - mountPath: /tmp/git + name: git + - args: + - --webhook-url + - http://localhost:9001/api/v1/sync + - --dest + - repo + env: + - name: GIT_SYNC_REPO + value: https://github.com/argoproj/argocd-example-apps + image: k8s.gcr.io/git-sync:v3.1.6 + name: git-sync + volumeMounts: + - mountPath: /tmp/git + name: git + serviceAccountName: gitops-agent + volumes: + - emptyDir: {} + name: git diff --git a/gitops-engine/agent/manifests/namespace-install/gitops-agent-deployment-overlay.yaml b/gitops-engine/agent/manifests/namespace-install/gitops-agent-deployment-overlay.yaml new file mode 100644 index 0000000000000..b41455229e668 --- /dev/null +++ b/gitops-engine/agent/manifests/namespace-install/gitops-agent-deployment-overlay.yaml @@ -0,0 +1,2 @@ +- {op: add, path: /spec/template/spec/containers/0/command/-, value: --namespaced} + diff --git a/gitops-engine/agent/manifests/namespace-install/gitops-agent-role-binding.yaml b/gitops-engine/agent/manifests/namespace-install/gitops-agent-role-binding.yaml new file mode 100644 index 0000000000000..a9e57fe528622 --- /dev/null +++ b/gitops-engine/agent/manifests/namespace-install/gitops-agent-role-binding.yaml @@ -0,0 +1,12 @@ +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: gitops-agent +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: gitops-agent +subjects: + - kind: ServiceAccount + name: gitops-agent diff --git a/gitops-engine/agent/manifests/namespace-install/gitops-agent-role.yaml b/gitops-engine/agent/manifests/namespace-install/gitops-agent-role.yaml new file mode 100644 index 0000000000000..5fb7bd95a09d7 --- /dev/null +++ b/gitops-engine/agent/manifests/namespace-install/gitops-agent-role.yaml @@ -0,0 +1,12 @@ +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: gitops-agent +rules: + - apiGroups: + - '*' + resources: + - '*' + verbs: + - '*' \ No newline at end of file diff --git a/gitops-engine/agent/manifests/namespace-install/kustomization.yaml b/gitops-engine/agent/manifests/namespace-install/kustomization.yaml new file mode 100644 index 0000000000000..8f346579a6d2b --- /dev/null +++ b/gitops-engine/agent/manifests/namespace-install/kustomization.yaml @@ -0,0 +1,17 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization + +bases: +- ../base + +resources: +- ./gitops-agent-role-binding.yaml +- ./gitops-agent-role.yaml + +patchesJson6902: + - target: + group: apps + version: v1 + kind: Deployment + name: gitops-agent + path: ./gitops-agent-deployment-overlay.yaml diff --git a/gitops-engine/docs/faq.md b/gitops-engine/docs/faq.md new file mode 100644 index 0000000000000..69c67a32a82a0 --- /dev/null +++ b/gitops-engine/docs/faq.md @@ -0,0 +1,73 @@ +# Frequently Asked Questions + +## General + +**Q**: What's the backstory behind this? + +**A**: In November 2019 the teams behind Argo CD and Flux announced that they were going to join efforts. Some of the announcement blog posts explain what the thinking of the time was: + +- Jay Pipes on the [AWS blog](https://aws.amazon.com/de/blogs/containers/help-us-write-a-new-chapter-for-gitops-kubernetes-and-open-source-collaboration/) +- Pratik Wadher on the [Intuit blog](https://www.intuit.com/blog/technology/introducing-argo-flux/) +- Tamao Nakahara on the [Weaveworks blog](https://www.weave.works/blog/argo-flux-join-forces) + +In the course of the next months, the two engineering teams [met on a regular basis](https://docs.google.com/document/d/17AEZgv6yVuD4HS7_oNPiMKmS7Q6vjkhk6jH0YCELpRk/edit) and scoped out the future of the project. Two options were on the table: + +1. Rethink APIs and build the project from the ground up. +1. Extract useful code from Argo into an Engine project. + +The latter was deemed to be the most practical solution. + +March 2020 the Flux team made a [proof of concept](https://github.com/fluxcd/flux/pull/2886) available, which rebased the Flux on top of the GitOps Engine, but while looking at the breaking changes this was going to introduce the Flux team decided that it was a time for a [more ground-breaking approach](https://www.weave.works/blog/gitops-with-flux-v2) on how to do GitOps. After some experimentation, the GitOps Toolkit was put out as an RFC in June 2020. + +A [number of other projects](https://github.com/search?q=argoproj%2Fgitops-engine&type=Code) already started looking at integrating the GitOps Engine. + +The Argo and Flux teams decided all of this on good terms. All of these discussions were immensely helpful in shaping both projects' future. You might see each of us stealing good ideas from the other in the future and celebrate each others successes. There might be future collaborations, we'll keep you posted. + +---- + +**Q**: What are you hoping to get out of this collaboration? + +**A**: Our primary motives for coming together to do this are: + +- Argo CD and Flux CD are two of the main GitOps projects, solving very similar problems, having very similar views on implementing GitOps. +- We want to offer a shared vision for GitOps and the best possible GitOps experience for everyone. +- We hope to bring a bigger community together than we can on our own. +- We want to learn from each other's approaches and offer the best in breed GitOps solution out there. + +---- + +**Q**: What can current Argo CD users look forward to from this collaboration with Flux CD? + +**A**: We hope Argo CD might get the following: + +- Docker registry monitoring feature. It would be fantastic if we could extract existing Flux CD code into a reusable component which works for both Argo CD and Flux CD. +- Better cluster management experience. Right now Argo CD users use app of apps pattern which is not perfect. Perhaps we can learn from Flux CD community and contribute to GitOps engine to improve both Argo CD and Flux CD. +- Advanced Git related features like GPG commit verification, git secrets. +- Simplified installations/management. + +---- + +**Q**: Does this project scope just synchronization of environment (git sync operator) or does it include progressive delivery? + +**A**: We will be starting to work on a spec for progressive delivery alignment between Argo Rollouts and Weave Flagger in 2020. + +---- + +**Q**: What comes after the GitOps Engine? + +**A**: The ultimate goal is to merge user experiences and eventually have one project. +Right now nobody knows how exactly that project will look like and how exactly we get there. We will start with baby steps e.g. get rid of code duplication (gitops engine), merge documentation, slacks/issues tracking and then incrementally try to merge CLI/UI to get one user experience. + +We also want to highlight that before we even start doing this we want to be properly introduced to each others communities, and understand each others use cases. As without this knowledge we won't be able to create something that will serve all of you. + +---- + +**Q**: Was it hard to put together the design for the GitOps Engine? What was most important to you when you started putting it together? + +**A**: It was hard for the right reasons. We wanted to design something which ticked off all these points: + +1. Realistic both in theory and practice (e.g. starting a new project from scratch didn't make sense, creating a Frankenstein-like project from pieces of both projects also didn't make sense). +1. Would allow us keep us nurturing the communities of Argo CD and Flux CD, towards a common product, without jeopardizing them (e.g. without disrespecting the communities). +1. Useful. Both projects would benefit from it as a first step towards a joint product/solution. + +In addition to that finding a common language, without falling into project specific terms (keeping it really abstract), was also quite a challenge, e.g. what a repository is to Flux CD, is an application to Argo CD. diff --git a/gitops-engine/docs/releasing.md b/gitops-engine/docs/releasing.md new file mode 100644 index 0000000000000..dcb2ef1c5c102 --- /dev/null +++ b/gitops-engine/docs/releasing.md @@ -0,0 +1,17 @@ +# Releasing + +This document describes the `gitops-engine` library releasing process. + +# Versioning + +* The library is versioned using the [semantic versioning](http://semver.org/): new version will be backwards-compatible +with earlier versions within a single major version. +* The library has its own release cycle and not tied to Argo CD release cycle. +* The first library release is v0.1.0. + +# Release process + +* Release branch is created for every minor release. +* The branch name should use the following convention: `release-.`. For example all v0.1 releases should +be in `release-0.1` branch. +* Actual release is a git tag which uses the following naming convention: `v--`. For example: `v0.1.0`, `v0.1.1` etc. \ No newline at end of file diff --git a/gitops-engine/go.mod b/gitops-engine/go.mod new file mode 100644 index 0000000000000..762ae99f83c3c --- /dev/null +++ b/gitops-engine/go.mod @@ -0,0 +1,140 @@ +module github.com/argoproj/gitops-engine + +go 1.24.0 + +require ( + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc + github.com/evanphx/json-patch/v5 v5.9.11 + github.com/go-logr/logr v1.4.3 + github.com/google/gnostic-models v0.7.0 + github.com/google/uuid v1.6.1-0.20241114170450-2d3c2a9cc518 + github.com/spf13/cobra v1.10.1 + github.com/stretchr/testify v1.11.1 + go.uber.org/mock v0.6.0 + golang.org/x/sync v0.17.0 + google.golang.org/protobuf v1.36.9 + k8s.io/api v0.34.0 + k8s.io/apiextensions-apiserver v0.34.0 + k8s.io/apimachinery v0.34.0 + k8s.io/cli-runtime v0.34.0 + k8s.io/client-go v0.34.0 + k8s.io/klog/v2 v2.130.1 + k8s.io/kube-aggregator v0.34.0 + k8s.io/kube-openapi v0.0.0-20250710124328-f3f2b991d03b + k8s.io/kubectl v0.34.0 + k8s.io/kubernetes v1.34.0 + sigs.k8s.io/structured-merge-diff/v6 v6.3.0 + sigs.k8s.io/yaml v1.6.0 +) + +require ( + github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect + github.com/MakeNowJust/heredoc v1.0.0 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/chai2010/gettext-go v1.0.3 // indirect + github.com/distribution/reference v0.6.0 // indirect + github.com/emicklei/go-restful/v3 v3.12.2 // indirect + github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect + github.com/fatih/camelcase v1.0.0 // indirect + github.com/fxamacker/cbor/v2 v2.9.0 // indirect + github.com/go-errors/errors v1.5.1 // indirect + github.com/go-openapi/jsonpointer v0.21.1 // indirect + github.com/go-openapi/jsonreference v0.21.0 // indirect + github.com/go-openapi/swag v0.23.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/google/btree v1.1.3 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect + github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jonboulle/clockwork v0.5.0 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect + github.com/mailru/easyjson v0.9.0 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/moby/spdystream v0.5.0 // indirect + github.com/moby/term v0.5.2 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect + github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect + github.com/onsi/ginkgo/v2 v2.22.0 // indirect + github.com/onsi/gomega v1.36.1 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/peterbourgon/diskv v2.0.1+incompatible // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.66.1 // indirect + github.com/prometheus/procfs v0.16.1 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect + github.com/spf13/pflag v1.0.10 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/x448/float16 v0.8.4 // indirect + github.com/xlab/treeprint v1.2.0 // indirect + go.opentelemetry.io/otel v1.38.0 // indirect + go.opentelemetry.io/otel/trace v1.38.0 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect + golang.org/x/net v0.44.0 // indirect + golang.org/x/oauth2 v0.31.0 // indirect + golang.org/x/sys v0.36.0 // indirect + golang.org/x/term v0.35.0 // indirect + golang.org/x/text v0.29.0 // indirect + golang.org/x/time v0.13.0 // indirect + gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + k8s.io/apiserver v0.34.0 // indirect + k8s.io/component-base v0.34.0 // indirect + k8s.io/component-helpers v0.34.0 // indirect + k8s.io/controller-manager v0.34.0 // indirect + k8s.io/utils v0.0.0-20250604170112-4c0f3b243397 // indirect + sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8 // indirect + sigs.k8s.io/kustomize/api v0.20.1 // indirect + sigs.k8s.io/kustomize/kyaml v0.20.1 // indirect + sigs.k8s.io/randfill v1.0.0 // indirect +) + +replace ( + // After bumping these versions, run hack/update_static_schema.sh in case the schema has changed. + k8s.io/api => k8s.io/api v0.34.0 + k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.34.0 + k8s.io/apimachinery => k8s.io/apimachinery v0.34.0 + k8s.io/apiserver => k8s.io/apiserver v0.34.0 + k8s.io/cli-runtime => k8s.io/cli-runtime v0.34.0 + k8s.io/client-go => k8s.io/client-go v0.34.0 + k8s.io/cloud-provider => k8s.io/cloud-provider v0.34.0 + k8s.io/cluster-bootstrap => k8s.io/cluster-bootstrap v0.34.0 + k8s.io/code-generator => k8s.io/code-generator v0.34.0 + k8s.io/component-base => k8s.io/component-base v0.34.0 + k8s.io/component-helpers => k8s.io/component-helpers v0.34.0 + k8s.io/controller-manager => k8s.io/controller-manager v0.34.0 + k8s.io/cri-api => k8s.io/cri-api v0.34.0 + k8s.io/cri-client => k8s.io/cri-client v0.34.0 + k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.34.0 + k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.34.0 + k8s.io/endpointslice => k8s.io/endpointslice v0.34.0 + k8s.io/externaljwt => k8s.io/externaljwt v0.34.0 + k8s.io/kms => k8s.io/kms v0.34.0 + k8s.io/kube-aggregator => k8s.io/kube-aggregator v0.34.0 + k8s.io/kube-controller-manager => k8s.io/kube-controller-manager v0.34.0 + k8s.io/kube-proxy => k8s.io/kube-proxy v0.34.0 + k8s.io/kube-scheduler => k8s.io/kube-scheduler v0.34.0 + k8s.io/kubectl => k8s.io/kubectl v0.34.0 + k8s.io/kubelet => k8s.io/kubelet v0.34.0 + k8s.io/legacy-cloud-providers => k8s.io/legacy-cloud-providers v0.34.0 + k8s.io/metrics => k8s.io/metrics v0.34.0 + k8s.io/mount-utils => k8s.io/mount-utils v0.34.0 + k8s.io/pod-security-admission => k8s.io/pod-security-admission v0.34.0 + k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.34.0 + k8s.io/sample-cli-plugin => k8s.io/sample-cli-plugin v0.34.0 + k8s.io/sample-controller => k8s.io/sample-controller v0.34.0 +) diff --git a/gitops-engine/go.sum b/gitops-engine/go.sum new file mode 100644 index 0000000000000..1fbcd29930b51 --- /dev/null +++ b/gitops-engine/go.sum @@ -0,0 +1,237 @@ +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ= +github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= +github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chai2010/gettext-go v1.0.3 h1:9liNh8t+u26xl5ddmWLmsOsdNLwkdRTg5AG+JnTiM80= +github.com/chai2010/gettext-go v1.0.3/go.mod h1:y+wnP2cHYaVj19NZhYKAwEMH2CI1gNHeQQ+5AjwawxA= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= +github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +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/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/emicklei/go-restful/v3 v3.12.2 h1:DhwDP0vY3k8ZzE0RunuJy8GhNpPL6zqLkDf9B/a0/xU= +github.com/emicklei/go-restful/v3 v3.12.2/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/evanphx/json-patch/v5 v5.9.11 h1:/8HVnzMq13/3x9TPvjG08wUGqBTmZBsCWzjTM0wiaDU= +github.com/evanphx/json-patch/v5 v5.9.11/go.mod h1:3j+LviiESTElxA4p3EMKAB9HXj3/XEtnUf6OZxqIQTM= +github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f h1:Wl78ApPPB2Wvf/TIe2xdyJxTlb6obmF18d8QdkxNDu4= +github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f/go.mod h1:OSYXu++VVOHnXeitef/D8n/6y4QV8uLHSFXX4NeXMGc= +github.com/fatih/camelcase v1.0.0 h1:hxNvNX/xYBp0ovncs8WyWZrOrpBNub/JfaMvbURyft8= +github.com/fatih/camelcase v1.0.0/go.mod h1:yN2Sb0lFhZJUdVvtELVWefmrXpuZESvPmqwoZc+/fpc= +github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM= +github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= +github.com/go-errors/errors v1.5.1 h1:ZwEMSLRCapFLflTpT7NKaAc7ukJ8ZPEjzlxt8rPN8bk= +github.com/go-errors/errors v1.5.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-openapi/jsonpointer v0.21.1 h1:whnzv/pNXtK2FbX/W9yJfRmE2gsmkfahjMKB0fZvcic= +github.com/go-openapi/jsonpointer v0.21.1/go.mod h1:50I1STOfbY1ycR8jGz8DaMeLCdXiI6aDteEdRNNzpdk= +github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ= +github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4= +github.com/go-openapi/swag v0.23.1 h1:lpsStH0n2ittzTnbaSloVZLuB5+fvSY/+hnagBjSNZU= +github.com/go-openapi/swag v0.23.1/go.mod h1:STZs8TbRvEQQKUA+JZNAm3EWlgaOBGpyFDqQnDHMef0= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= +github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= +github.com/google/gnostic-models v0.7.0 h1:qwTtogB15McXDaNqTZdzPJRHvaVJlAl+HVQnLmJEJxo= +github.com/google/gnostic-models v0.7.0/go.mod h1:whL5G0m6dmc5cPxKc5bdKdEN3UjI7OUGxBlw57miDrQ= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/uuid v1.6.1-0.20241114170450-2d3c2a9cc518 h1:UBg1xk+oAsIVbFuGg6hdfAm7EvCv3EL80vFxJNsslqw= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 h1:JeSE6pjso5THxAzdVpqr6/geYxZytqFMBCOtn/ujyeo= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674/go.mod h1:r4w70xmWCQKmi1ONH4KIaBptdivuRPyosB9RmPlGEwA= +github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 h1:+ngKgrYPPJrOjhax5N+uePQ0Fh1Z7PheYoUI/0nzkPA= +github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jonboulle/clockwork v0.5.0 h1:Hyh9A8u51kptdkR+cqRpT1EebBwTn1oK9YfGYbdFz6I= +github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7XN3SzBPjZF60= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +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/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de h1:9TO3cAIGXtEhnIaL+V+BEER86oLrvS+kWobKpbJuye0= +github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de/go.mod h1:zAbeS9B/r2mtpb6U+EI2rYA5OAXxsYw6wTamcNW+zcE= +github.com/lithammer/dedent v1.1.0 h1:VNzHMVCBNG1j0fh3OrsFRkVUwStdDArbgBWoPAffktY= +github.com/lithammer/dedent v1.1.0/go.mod h1:jrXYCQtgg0nJiN+StA2KgR7w6CiQNv9Fd/Z9BP0jIOc= +github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4= +github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU= +github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= +github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/moby/spdystream v0.5.0 h1:7r0J1Si3QO/kjRitvSLVVFUjxMEb/YLj6S9FF62JBCU= +github.com/moby/spdystream v0.5.0/go.mod h1:xBAYlnt/ay+11ShkdFKNAG7LsyK/tmNBVvVOwrfMgdI= +github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ= +github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw= +github.com/onsi/ginkgo/v2 v2.22.0 h1:Yed107/8DjTr0lKCNt7Dn8yQ6ybuDRQoMGrNFKzMfHg= +github.com/onsi/gomega v1.36.1 h1:bJDPBO7ibjxcbHMgSCoo4Yj18UWbKDlLwX1x9sybDcw= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI= +github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= +github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= +github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s= +github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ= +github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8= +go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +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.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I= +golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo= +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/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +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.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k= +golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ= +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.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk= +golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI= +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/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +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/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw= +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/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= +gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +k8s.io/api v0.34.0 h1:L+JtP2wDbEYPUeNGbeSa/5GwFtIA662EmT2YSLOkAVE= +k8s.io/api v0.34.0/go.mod h1:YzgkIzOOlhl9uwWCZNqpw6RJy9L2FK4dlJeayUoydug= +k8s.io/apiextensions-apiserver v0.34.0 h1:B3hiB32jV7BcyKcMU5fDaDxk882YrJ1KU+ZSkA9Qxoc= +k8s.io/apiextensions-apiserver v0.34.0/go.mod h1:hLI4GxE1BDBy9adJKxUxCEHBGZtGfIg98Q+JmTD7+g0= +k8s.io/apimachinery v0.34.0 h1:eR1WO5fo0HyoQZt1wdISpFDffnWOvFLOOeJ7MgIv4z0= +k8s.io/apimachinery v0.34.0/go.mod h1:/GwIlEcWuTX9zKIg2mbw0LRFIsXwrfoVxn+ef0X13lw= +k8s.io/apiserver v0.34.0 h1:Z51fw1iGMqN7uJ1kEaynf2Aec1Y774PqU+FVWCFV3Jg= +k8s.io/apiserver v0.34.0/go.mod h1:52ti5YhxAvewmmpVRqlASvaqxt0gKJxvCeW7ZrwgazQ= +k8s.io/cli-runtime v0.34.0 h1:N2/rUlJg6TMEBgtQ3SDRJwa8XyKUizwjlOknT1mB2Cw= +k8s.io/cli-runtime v0.34.0/go.mod h1:t/skRecS73Piv+J+FmWIQA2N2/rDjdYSQzEE67LUUs8= +k8s.io/client-go v0.34.0 h1:YoWv5r7bsBfb0Hs2jh8SOvFbKzzxyNo0nSb0zC19KZo= +k8s.io/client-go v0.34.0/go.mod h1:ozgMnEKXkRjeMvBZdV1AijMHLTh3pbACPvK7zFR+QQY= +k8s.io/component-base v0.34.0 h1:bS8Ua3zlJzapklsB1dZgjEJuJEeHjj8yTu1gxE2zQX8= +k8s.io/component-base v0.34.0/go.mod h1:RSCqUdvIjjrEm81epPcjQ/DS+49fADvGSCkIP3IC6vg= +k8s.io/component-helpers v0.34.0 h1:5T7P9XGMoUy1JDNKzHf0p/upYbeUf8ZaSf9jbx0QlIo= +k8s.io/component-helpers v0.34.0/go.mod h1:kaOyl5tdtnymriYcVZg4uwDBe2d1wlIpXyDkt6sVnt4= +k8s.io/controller-manager v0.34.0 h1:oCHoqS8dcFp7zDSu7HUvTpakq3isSxil3GprGGlJMsE= +k8s.io/controller-manager v0.34.0/go.mod h1:XFto21U+Mm9BT8r/Jd5E4tHCGtwjKAUFOuDcqaj2VK0= +k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= +k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= +k8s.io/kube-aggregator v0.34.0 h1:XE4u+HOYkj0g44sblhTtPv+QyIIK7sJxrIlia0731kE= +k8s.io/kube-aggregator v0.34.0/go.mod h1:GIUqdChXVC448Vp2Wgxf0m6fir7Xt3A2TAZcs2JNG1Y= +k8s.io/kube-openapi v0.0.0-20250710124328-f3f2b991d03b h1:MloQ9/bdJyIu9lb1PzujOPolHyvO06MXG5TUIj2mNAA= +k8s.io/kube-openapi v0.0.0-20250710124328-f3f2b991d03b/go.mod h1:UZ2yyWbFTpuhSbFhv24aGNOdoRdJZgsIObGBUaYVsts= +k8s.io/kubectl v0.34.0 h1:NcXz4TPTaUwhiX4LU+6r6udrlm0NsVnSkP3R9t0dmxs= +k8s.io/kubectl v0.34.0/go.mod h1:bmd0W5i+HuG7/p5sqicr0Li0rR2iIhXL0oUyLF3OjR4= +k8s.io/kubernetes v1.34.0 h1:NvUrwPAVB4W3mSOpJ/RtNGHWWYyUP/xPaX5rUSpzA0w= +k8s.io/kubernetes v1.34.0/go.mod h1:iu+FhII+Oc/1gGWLJcer6wpyih441aNFHl7Pvm8yPto= +k8s.io/utils v0.0.0-20250604170112-4c0f3b243397 h1:hwvWFiBzdWw1FhfY1FooPn3kzWuJ8tmbZBHi4zVsl1Y= +k8s.io/utils v0.0.0-20250604170112-4c0f3b243397/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8 h1:gBQPwqORJ8d8/YNZWEjoZs7npUVDpVXUUOFfW6CgAqE= +sigs.k8s.io/json v0.0.0-20241014173422-cfa47c3a1cc8/go.mod h1:mdzfpAEoE6DHQEN0uh9ZbOCuHbLK5wOm7dK4ctXE9Tg= +sigs.k8s.io/kustomize/api v0.20.1 h1:iWP1Ydh3/lmldBnH/S5RXgT98vWYMaTUL1ADcr+Sv7I= +sigs.k8s.io/kustomize/api v0.20.1/go.mod h1:t6hUFxO+Ph0VxIk1sKp1WS0dOjbPCtLJ4p8aADLwqjM= +sigs.k8s.io/kustomize/kyaml v0.20.1 h1:PCMnA2mrVbRP3NIB6v9kYCAc38uvFLVs8j/CD567A78= +sigs.k8s.io/kustomize/kyaml v0.20.1/go.mod h1:0EmkQHRUsJxY8Ug9Niig1pUMSCGHxQ5RklbpV/Ri6po= +sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU= +sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/structured-merge-diff/v6 v6.3.0 h1:jTijUJbW353oVOd9oTlifJqOGEkUw2jB/fXCbTiQEco= +sigs.k8s.io/structured-merge-diff/v6 v6.3.0/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE= +sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= +sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= diff --git a/gitops-engine/hack/update_static_schema.sh b/gitops-engine/hack/update_static_schema.sh new file mode 100755 index 0000000000000..4b4d403f4e1f8 --- /dev/null +++ b/gitops-engine/hack/update_static_schema.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash + +set -euox pipefail + +# Get the k8s library version from go.mod, stripping the trailing newline +k8s_lib_version=$(grep "k8s.io/client-go" go.mod | awk '{print $2}' | head -n 1 | tr -d '\n') + +# Download the parser file from the k8s library +curl -sL "https://raw.githubusercontent.com/kubernetes/client-go/$k8s_lib_version/applyconfigurations/internal/internal.go" -o pkg/utils/kube/scheme/parser.go + +# Add a line to the beginning of the file saying that this is the script that generated it. +sed -i '' '1s/^/\/\/ Code generated by hack\/update_static_schema.sh; DO NOT EDIT.\n\/\/ Everything below is downloaded from applyconfigurations\/internal\/internal.go in kubernetes\/client-go.\n\n/' pkg/utils/kube/scheme/parser.go + +# Replace "package internal" with "package scheme" in the parser file +sed -i '' 's/package internal/package scheme/' pkg/utils/kube/scheme/parser.go + +# Replace "func Parser" with "func StaticParser" +sed -i '' 's/func Parser/func StaticParser/' pkg/utils/kube/scheme/parser.go diff --git a/gitops-engine/internal/kubernetes_vendor/pkg/api/v1/endpoints/util.go b/gitops-engine/internal/kubernetes_vendor/pkg/api/v1/endpoints/util.go new file mode 100644 index 0000000000000..58b7c13331f66 --- /dev/null +++ b/gitops-engine/internal/kubernetes_vendor/pkg/api/v1/endpoints/util.go @@ -0,0 +1,90 @@ +/* +Copyright 2015 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 endpoints + +import ( + "bytes" + "crypto/md5" + "hash" + "sort" + + hashutil "github.com/argoproj/gitops-engine/internal/kubernetes_vendor/pkg/util/hash" + v1 "k8s.io/api/core/v1" +) + +// LessEndpointAddress compares IP addresses lexicographically and returns true if first argument is lesser than second +func LessEndpointAddress(a, b *v1.EndpointAddress) bool { + ipComparison := bytes.Compare([]byte(a.IP), []byte(b.IP)) + if ipComparison != 0 { + return ipComparison < 0 + } + if b.TargetRef == nil { + return false + } + if a.TargetRef == nil { + return true + } + return a.TargetRef.UID < b.TargetRef.UID +} + +// SortSubsets sorts an array of EndpointSubset objects in place. For ease of +// use it returns the input slice. +func SortSubsets(subsets []v1.EndpointSubset) []v1.EndpointSubset { + for i := range subsets { + ss := &subsets[i] + sort.Sort(addrsByIPAndUID(ss.Addresses)) + sort.Sort(addrsByIPAndUID(ss.NotReadyAddresses)) + sort.Sort(portsByHash(ss.Ports)) + } + sort.Sort(subsetsByHash(subsets)) + return subsets +} + +func hashObject(hasher hash.Hash, obj interface{}) []byte { + hashutil.DeepHashObject(hasher, obj) + return hasher.Sum(nil) +} + +type subsetsByHash []v1.EndpointSubset + +func (sl subsetsByHash) Len() int { return len(sl) } +func (sl subsetsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] } +func (sl subsetsByHash) Less(i, j int) bool { + hasher := md5.New() + h1 := hashObject(hasher, sl[i]) + h2 := hashObject(hasher, sl[j]) + return bytes.Compare(h1, h2) < 0 +} + +type addrsByIPAndUID []v1.EndpointAddress + +func (sl addrsByIPAndUID) Len() int { return len(sl) } +func (sl addrsByIPAndUID) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] } +func (sl addrsByIPAndUID) Less(i, j int) bool { + return LessEndpointAddress(&sl[i], &sl[j]) +} + +type portsByHash []v1.EndpointPort + +func (sl portsByHash) Len() int { return len(sl) } +func (sl portsByHash) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] } +func (sl portsByHash) Less(i, j int) bool { + hasher := md5.New() + h1 := hashObject(hasher, sl[i]) + h2 := hashObject(hasher, sl[j]) + return bytes.Compare(h1, h2) < 0 +} diff --git a/gitops-engine/internal/kubernetes_vendor/pkg/util/hash/hash.go b/gitops-engine/internal/kubernetes_vendor/pkg/util/hash/hash.go new file mode 100644 index 0000000000000..803f066a440b3 --- /dev/null +++ b/gitops-engine/internal/kubernetes_vendor/pkg/util/hash/hash.go @@ -0,0 +1,37 @@ +/* +Copyright 2015 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 hash + +import ( + "hash" + + "github.com/davecgh/go-spew/spew" +) + +// DeepHashObject writes specified object to hash using the spew library +// which follows pointers and prints actual values of the nested objects +// ensuring the hash does not change when a pointer changes. +func DeepHashObject(hasher hash.Hash, objectToWrite interface{}) { + hasher.Reset() + printer := spew.ConfigState{ + Indent: " ", + SortKeys: true, + DisableMethods: true, + SpewKeys: true, + } + printer.Fprintf(hasher, "%#v", objectToWrite) +} diff --git a/gitops-engine/pkg/cache/cluster.go b/gitops-engine/pkg/cache/cluster.go new file mode 100644 index 0000000000000..38f1e6016c30c --- /dev/null +++ b/gitops-engine/pkg/cache/cluster.go @@ -0,0 +1,1396 @@ +package cache + +import ( + "context" + "fmt" + "runtime/debug" + "strings" + "sync" + "time" + + "github.com/go-logr/logr" + "golang.org/x/sync/semaphore" + authorizationv1 "k8s.io/api/authorization/v1" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/kubernetes" + authType1 "k8s.io/client-go/kubernetes/typed/authorization/v1" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/tools/pager" + watchutil "k8s.io/client-go/tools/watch" + "k8s.io/client-go/util/retry" + "k8s.io/klog/v2/textlogger" + "k8s.io/kubectl/pkg/util/openapi" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +const ( + watchResourcesRetryTimeout = 1 * time.Second + ClusterRetryTimeout = 10 * time.Second + + // default duration before we invalidate entire cluster cache. Can be set to 0 to never invalidate cache + defaultClusterResyncTimeout = 24 * time.Hour + + // default duration before restarting individual resource watch + defaultWatchResyncTimeout = 10 * time.Minute + + // Same page size as in k8s.io/client-go/tools/pager/pager.go + defaultListPageSize = 500 + // Prefetch only a single page + defaultListPageBufferSize = 1 + // listSemaphore is used to limit the number of concurrent memory consuming operations on the + // k8s list queries results. + // Limit is required to avoid memory spikes during cache initialization. + // The default limit of 50 is chosen based on experiments. + defaultListSemaphoreWeight = 50 + // defaultEventProcessingInterval is the default interval for processing events + defaultEventProcessingInterval = 100 * time.Millisecond +) + +const ( + // RespectRbacDisabled default value for respectRbac + RespectRbacDisabled = iota + // RespectRbacNormal checks only api response for forbidden/unauthorized errors + RespectRbacNormal + // RespectRbacStrict checks both api response for forbidden/unauthorized errors and SelfSubjectAccessReview + RespectRbacStrict +) + +type apiMeta struct { + namespaced bool + // watchCancel stops the watch of all resources for this API. This gets called when the cache is invalidated or when + // the watched API ceases to exist (e.g. a CRD gets deleted). + watchCancel context.CancelFunc +} + +type eventMeta struct { + event watch.EventType + un *unstructured.Unstructured +} + +// ClusterInfo holds cluster cache stats +type ClusterInfo struct { + // Server holds cluster API server URL + Server string + // K8SVersion holds Kubernetes version + K8SVersion string + // ResourcesCount holds number of observed Kubernetes resources + ResourcesCount int + // APIsCount holds number of observed Kubernetes API count + APIsCount int + // LastCacheSyncTime holds time of most recent cache synchronization + LastCacheSyncTime *time.Time + // SyncError holds most recent cache synchronization error + SyncError error + // APIResources holds list of API resources supported by the cluster + APIResources []kube.APIResourceInfo +} + +// OnEventHandler is a function that handles Kubernetes event +type OnEventHandler func(event watch.EventType, un *unstructured.Unstructured) + +// OnProcessEventsHandler handles process events event +type OnProcessEventsHandler func(duration time.Duration, processedEventsNumber int) + +// OnPopulateResourceInfoHandler returns additional resource metadata that should be stored in cache +type OnPopulateResourceInfoHandler func(un *unstructured.Unstructured, isRoot bool) (info any, cacheManifest bool) + +// OnResourceUpdatedHandler handlers resource update event +type ( + OnResourceUpdatedHandler func(newRes *Resource, oldRes *Resource, namespaceResources map[kube.ResourceKey]*Resource) + Unsubscribe func() +) + +type ClusterCache interface { + // EnsureSynced checks cache state and synchronizes it if necessary + EnsureSynced() error + // GetServerVersion returns observed cluster version + GetServerVersion() string + // GetAPIResources returns information about observed API resources + GetAPIResources() []kube.APIResourceInfo + // GetOpenAPISchema returns open API schema of supported API resources + GetOpenAPISchema() openapi.Resources + // GetGVKParser returns a parser able to build a TypedValue used in + // structured merge diffs. + GetGVKParser() *managedfields.GvkParser + // Invalidate cache and executes callback that optionally might update cache settings + Invalidate(opts ...UpdateSettingsFunc) + // FindResources returns resources that matches given list of predicates from specified namespace or everywhere if specified namespace is empty + FindResources(namespace string, predicates ...func(r *Resource) bool) map[kube.ResourceKey]*Resource + // IterateHierarchyV2 iterates resource tree starting from the specified top level resources and executes callback for each resource in the tree. + // The action callback returns true if iteration should continue and false otherwise. + IterateHierarchyV2(keys []kube.ResourceKey, action func(resource *Resource, namespaceResources map[kube.ResourceKey]*Resource) bool) + // IsNamespaced answers if specified group/kind is a namespaced resource API or not + IsNamespaced(gk schema.GroupKind) (bool, error) + // GetManagedLiveObjs helps finding matching live K8S resources for a given resources list. + // The function returns all resources from cache for those `isManaged` function returns true and resources + // specified in targetObjs list. + GetManagedLiveObjs(targetObjs []*unstructured.Unstructured, isManaged func(r *Resource) bool) (map[kube.ResourceKey]*unstructured.Unstructured, error) + // GetClusterInfo returns cluster cache statistics + GetClusterInfo() ClusterInfo + // OnResourceUpdated register event handler that is executed every time when resource get's updated in the cache + OnResourceUpdated(handler OnResourceUpdatedHandler) Unsubscribe + // OnEvent register event handler that is executed every time when new K8S event received + OnEvent(handler OnEventHandler) Unsubscribe + // OnProcessEventsHandler register event handler that is executed every time when events were processed + OnProcessEventsHandler(handler OnProcessEventsHandler) Unsubscribe +} + +type WeightedSemaphore interface { + Acquire(ctx context.Context, n int64) error + TryAcquire(n int64) bool + Release(n int64) +} + +type ListRetryFunc func(err error) bool + +// NewClusterCache creates new instance of cluster cache +func NewClusterCache(config *rest.Config, opts ...UpdateSettingsFunc) *clusterCache { + log := textlogger.NewLogger(textlogger.NewConfig()) + cache := &clusterCache{ + settings: Settings{ResourceHealthOverride: &noopSettings{}, ResourcesFilter: &noopSettings{}}, + apisMeta: make(map[schema.GroupKind]*apiMeta), + eventMetaCh: nil, + listPageSize: defaultListPageSize, + listPageBufferSize: defaultListPageBufferSize, + listSemaphore: semaphore.NewWeighted(defaultListSemaphoreWeight), + resources: make(map[kube.ResourceKey]*Resource), + nsIndex: make(map[string]map[kube.ResourceKey]*Resource), + config: config, + kubectl: &kube.KubectlCmd{ + Log: log, + Tracer: tracing.NopTracer{}, + }, + syncStatus: clusterCacheSync{ + resyncTimeout: defaultClusterResyncTimeout, + syncTime: nil, + }, + watchResyncTimeout: defaultWatchResyncTimeout, + clusterSyncRetryTimeout: ClusterRetryTimeout, + eventProcessingInterval: defaultEventProcessingInterval, + resourceUpdatedHandlers: map[uint64]OnResourceUpdatedHandler{}, + eventHandlers: map[uint64]OnEventHandler{}, + processEventsHandlers: map[uint64]OnProcessEventsHandler{}, + log: log, + listRetryLimit: 1, + listRetryUseBackoff: false, + listRetryFunc: ListRetryFuncNever, + } + for i := range opts { + opts[i](cache) + } + return cache +} + +type clusterCache struct { + syncStatus clusterCacheSync + + apisMeta map[schema.GroupKind]*apiMeta + batchEventsProcessing bool + eventMetaCh chan eventMeta + serverVersion string + apiResources []kube.APIResourceInfo + // namespacedResources is a simple map which indicates a groupKind is namespaced + namespacedResources map[schema.GroupKind]bool + + // maximum time we allow watches to run before relisting the group/kind and restarting the watch + watchResyncTimeout time.Duration + // sync retry timeout for cluster when sync error happens + clusterSyncRetryTimeout time.Duration + // ticker interval for events processing + eventProcessingInterval time.Duration + + // size of a page for list operations pager. + listPageSize int64 + // number of pages to prefetch for list pager. + listPageBufferSize int32 + listSemaphore WeightedSemaphore + + // retry options for list operations + listRetryLimit int32 + listRetryUseBackoff bool + listRetryFunc ListRetryFunc + + // lock is a rw lock which protects the fields of clusterInfo + lock sync.RWMutex + resources map[kube.ResourceKey]*Resource + nsIndex map[string]map[kube.ResourceKey]*Resource + + kubectl kube.Kubectl + log logr.Logger + config *rest.Config + namespaces []string + clusterResources bool + settings Settings + + handlersLock sync.Mutex + handlerKey uint64 + populateResourceInfoHandler OnPopulateResourceInfoHandler + resourceUpdatedHandlers map[uint64]OnResourceUpdatedHandler + eventHandlers map[uint64]OnEventHandler + processEventsHandlers map[uint64]OnProcessEventsHandler + openAPISchema openapi.Resources + gvkParser *managedfields.GvkParser + + respectRBAC int +} + +type clusterCacheSync struct { + // When using this struct: + // 1) 'lock' mutex should be acquired when reading/writing from fields of this struct. + // 2) The parent 'clusterCache.lock' does NOT need to be owned to r/w from fields of this struct (if it is owned, that is fine, but see below) + // 3) To prevent deadlocks, do not acquire parent 'clusterCache.lock' after acquiring this lock; if you need both locks, always acquire the parent lock first + lock sync.Mutex + syncTime *time.Time + syncError error + resyncTimeout time.Duration +} + +// ListRetryFuncNever never retries on errors +func ListRetryFuncNever(_ error) bool { + return false +} + +// ListRetryFuncAlways always retries on errors +func ListRetryFuncAlways(_ error) bool { + return true +} + +// OnResourceUpdated register event handler that is executed every time when resource get's updated in the cache +func (c *clusterCache) OnResourceUpdated(handler OnResourceUpdatedHandler) Unsubscribe { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + key := c.handlerKey + c.handlerKey++ + c.resourceUpdatedHandlers[key] = handler + return func() { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + delete(c.resourceUpdatedHandlers, key) + } +} + +func (c *clusterCache) getResourceUpdatedHandlers() []OnResourceUpdatedHandler { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + var handlers []OnResourceUpdatedHandler + for _, h := range c.resourceUpdatedHandlers { + handlers = append(handlers, h) + } + return handlers +} + +// OnEvent register event handler that is executed every time when new K8S event received +func (c *clusterCache) OnEvent(handler OnEventHandler) Unsubscribe { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + key := c.handlerKey + c.handlerKey++ + c.eventHandlers[key] = handler + return func() { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + delete(c.eventHandlers, key) + } +} + +func (c *clusterCache) getEventHandlers() []OnEventHandler { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + handlers := make([]OnEventHandler, 0, len(c.eventHandlers)) + for _, h := range c.eventHandlers { + handlers = append(handlers, h) + } + return handlers +} + +// OnProcessEventsHandler register event handler that is executed every time when events were processed +func (c *clusterCache) OnProcessEventsHandler(handler OnProcessEventsHandler) Unsubscribe { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + key := c.handlerKey + c.handlerKey++ + c.processEventsHandlers[key] = handler + return func() { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + delete(c.processEventsHandlers, key) + } +} + +func (c *clusterCache) getProcessEventsHandlers() []OnProcessEventsHandler { + c.handlersLock.Lock() + defer c.handlersLock.Unlock() + handlers := make([]OnProcessEventsHandler, 0, len(c.processEventsHandlers)) + for _, h := range c.processEventsHandlers { + handlers = append(handlers, h) + } + return handlers +} + +// GetServerVersion returns observed cluster version +func (c *clusterCache) GetServerVersion() string { + return c.serverVersion +} + +// GetAPIResources returns information about observed API resources +// This method is called frequently during reconciliation to pass API resource info to `helm template` +// NOTE: we do not provide any consistency guarantees about the returned list. The list might be +// updated in place (anytime new CRDs are introduced or removed). If necessary, a separate method +// would need to be introduced to return a copy of the list so it can be iterated consistently. +func (c *clusterCache) GetAPIResources() []kube.APIResourceInfo { + return c.apiResources +} + +// GetOpenAPISchema returns open API schema of supported API resources +func (c *clusterCache) GetOpenAPISchema() openapi.Resources { + return c.openAPISchema +} + +// GetGVKParser returns a parser able to build a TypedValue used in +// structured merge diffs. +func (c *clusterCache) GetGVKParser() *managedfields.GvkParser { + return c.gvkParser +} + +func (c *clusterCache) appendAPIResource(info kube.APIResourceInfo) { + exists := false + for i := range c.apiResources { + if c.apiResources[i].GroupKind == info.GroupKind && c.apiResources[i].GroupVersionResource.Version == info.GroupVersionResource.Version { + exists = true + break + } + } + if !exists { + c.apiResources = append(c.apiResources, info) + } +} + +func (c *clusterCache) deleteAPIResource(info kube.APIResourceInfo) { + for i := range c.apiResources { + if c.apiResources[i].GroupKind == info.GroupKind && c.apiResources[i].GroupVersionResource.Version == info.GroupVersionResource.Version { + c.apiResources[i] = c.apiResources[len(c.apiResources)-1] + c.apiResources = c.apiResources[:len(c.apiResources)-1] + break + } + } +} + +func (c *clusterCache) replaceResourceCache(gk schema.GroupKind, resources []*Resource, ns string) { + objByKey := make(map[kube.ResourceKey]*Resource) + for i := range resources { + objByKey[resources[i].ResourceKey()] = resources[i] + } + + // update existing nodes + for i := range resources { + res := resources[i] + oldRes := c.resources[res.ResourceKey()] + if oldRes == nil || oldRes.ResourceVersion != res.ResourceVersion { + c.onNodeUpdated(oldRes, res) + } + } + + for key := range c.resources { + if key.Kind != gk.Kind || key.Group != gk.Group || ns != "" && key.Namespace != ns { + continue + } + + if _, ok := objByKey[key]; !ok { + c.onNodeRemoved(key) + } + } +} + +func (c *clusterCache) newResource(un *unstructured.Unstructured) *Resource { + ownerRefs, isInferredParentOf := c.resolveResourceReferences(un) + + cacheManifest := false + var info any + if c.populateResourceInfoHandler != nil { + info, cacheManifest = c.populateResourceInfoHandler(un, len(ownerRefs) == 0) + } + var creationTimestamp *metav1.Time + ct := un.GetCreationTimestamp() + if !ct.IsZero() { + creationTimestamp = &ct + } + resource := &Resource{ + ResourceVersion: un.GetResourceVersion(), + Ref: kube.GetObjectRef(un), + OwnerRefs: ownerRefs, + Info: info, + CreationTimestamp: creationTimestamp, + isInferredParentOf: isInferredParentOf, + } + if cacheManifest { + resource.Resource = un + } + + return resource +} + +func (c *clusterCache) setNode(n *Resource) { + key := n.ResourceKey() + c.resources[key] = n + ns, ok := c.nsIndex[key.Namespace] + if !ok { + ns = make(map[kube.ResourceKey]*Resource) + c.nsIndex[key.Namespace] = ns + } + ns[key] = n + + // update inferred parent references + if n.isInferredParentOf != nil || mightHaveInferredOwner(n) { + for k, v := range ns { + // update child resource owner references + if n.isInferredParentOf != nil && mightHaveInferredOwner(v) { + v.setOwnerRef(n.toOwnerRef(), n.isInferredParentOf(k)) + } + if mightHaveInferredOwner(n) && v.isInferredParentOf != nil { + n.setOwnerRef(v.toOwnerRef(), v.isInferredParentOf(n.ResourceKey())) + } + } + } +} + +// Invalidate cache and executes callback that optionally might update cache settings +func (c *clusterCache) Invalidate(opts ...UpdateSettingsFunc) { + c.lock.Lock() + defer c.lock.Unlock() + + c.syncStatus.lock.Lock() + c.syncStatus.syncTime = nil + c.syncStatus.lock.Unlock() + + for i := range c.apisMeta { + c.apisMeta[i].watchCancel() + } + for i := range opts { + opts[i](c) + } + + if c.batchEventsProcessing { + c.invalidateEventMeta() + } + c.apisMeta = nil + c.namespacedResources = nil + c.log.Info("Invalidated cluster") +} + +// clusterCacheSync's lock should be held before calling this method +func (syncStatus *clusterCacheSync) synced(clusterRetryTimeout time.Duration) bool { + syncTime := syncStatus.syncTime + + if syncTime == nil { + return false + } + if syncStatus.syncError != nil { + return time.Now().Before(syncTime.Add(clusterRetryTimeout)) + } + if syncStatus.resyncTimeout == 0 { + // cluster resync timeout has been disabled + return true + } + return time.Now().Before(syncTime.Add(syncStatus.resyncTimeout)) +} + +func (c *clusterCache) stopWatching(gk schema.GroupKind, ns string) { + c.lock.Lock() + defer c.lock.Unlock() + if info, ok := c.apisMeta[gk]; ok { + info.watchCancel() + delete(c.apisMeta, gk) + c.replaceResourceCache(gk, nil, ns) + c.log.Info(fmt.Sprintf("Stop watching: %s not found", gk)) + } +} + +// startMissingWatches lists supported cluster resources and starts watching for changes unless watch is already running +func (c *clusterCache) startMissingWatches() error { + apis, err := c.kubectl.GetAPIResources(c.config, true, c.settings.ResourcesFilter) + if err != nil { + return fmt.Errorf("failed to get APIResources: %w", err) + } + client, err := c.kubectl.NewDynamicClient(c.config) + if err != nil { + return fmt.Errorf("failed to create client: %w", err) + } + clientset, err := kubernetes.NewForConfig(c.config) + if err != nil { + return fmt.Errorf("failed to create clientset: %w", err) + } + namespacedResources := make(map[schema.GroupKind]bool) + for i := range apis { + api := apis[i] + namespacedResources[api.GroupKind] = api.Meta.Namespaced + if _, ok := c.apisMeta[api.GroupKind]; !ok { + ctx, cancel := context.WithCancel(context.Background()) + c.apisMeta[api.GroupKind] = &apiMeta{namespaced: api.Meta.Namespaced, watchCancel: cancel} + + err := c.processApi(client, api, func(resClient dynamic.ResourceInterface, ns string) error { + resourceVersion, err := c.loadInitialState(ctx, api, resClient, ns, false) // don't lock here, we are already in a lock before startMissingWatches is called inside watchEvents + if err != nil && c.isRestrictedResource(err) { + keep := false + if c.respectRBAC == RespectRbacStrict { + k, permErr := c.checkPermission(ctx, clientset.AuthorizationV1().SelfSubjectAccessReviews(), api) + if permErr != nil { + return fmt.Errorf("failed to check permissions for resource %s: %w, original error=%v", api.GroupKind.String(), permErr, err.Error()) + } + keep = k + } + // if we are not allowed to list the resource, remove it from the watch list + if !keep { + delete(c.apisMeta, api.GroupKind) + delete(namespacedResources, api.GroupKind) + return nil + } + } + go c.watchEvents(ctx, api, resClient, ns, resourceVersion) + return nil + }) + if err != nil { + return err + } + } + } + c.namespacedResources = namespacedResources + return nil +} + +func runSynced(lock sync.Locker, action func() error) error { + lock.Lock() + defer lock.Unlock() + return action() +} + +// listResources creates list pager and enforces number of concurrent list requests +// The callback should not wait on any locks that may be held by other callers. +func (c *clusterCache) listResources(ctx context.Context, resClient dynamic.ResourceInterface, callback func(*pager.ListPager) error) (string, error) { + if err := c.listSemaphore.Acquire(ctx, 1); err != nil { + return "", fmt.Errorf("failed to acquire list semaphore: %w", err) + } + defer c.listSemaphore.Release(1) + + var retryCount int64 + resourceVersion := "" + listPager := pager.New(func(ctx context.Context, opts metav1.ListOptions) (runtime.Object, error) { + var res *unstructured.UnstructuredList + var listRetry wait.Backoff + + if c.listRetryUseBackoff { + listRetry = retry.DefaultBackoff + } else { + listRetry = retry.DefaultRetry + } + + listRetry.Steps = int(c.listRetryLimit) + err := retry.OnError(listRetry, c.listRetryFunc, func() error { + var ierr error + res, ierr = resClient.List(ctx, opts) + if ierr != nil { + // Log out a retry + if c.listRetryLimit > 1 && c.listRetryFunc(ierr) { + retryCount++ + c.log.Info(fmt.Sprintf("Error while listing resources: %v (try %d/%d)", ierr, retryCount, c.listRetryLimit)) + } + //nolint:wrapcheck // wrap outside the retry + return ierr + } + resourceVersion = res.GetResourceVersion() + return nil + }) + if err != nil { + return res, fmt.Errorf("failed to list resources: %w", err) + } + return res, nil + }) + listPager.PageBufferSize = c.listPageBufferSize + listPager.PageSize = c.listPageSize + + return resourceVersion, callback(listPager) +} + +// loadInitialState loads the state of all the resources retrieved by the given resource client. +func (c *clusterCache) loadInitialState(ctx context.Context, api kube.APIResourceInfo, resClient dynamic.ResourceInterface, ns string, lock bool) (string, error) { + var items []*Resource + resourceVersion, err := c.listResources(ctx, resClient, func(listPager *pager.ListPager) error { + return listPager.EachListItem(ctx, metav1.ListOptions{}, func(obj runtime.Object) error { + if un, ok := obj.(*unstructured.Unstructured); !ok { + return fmt.Errorf("object %s/%s has an unexpected type", un.GroupVersionKind().String(), un.GetName()) + } else { + items = append(items, c.newResource(un)) + } + return nil + }) + }) + if err != nil { + return "", fmt.Errorf("failed to load initial state of resource %s: %w", api.GroupKind.String(), err) + } + + if lock { + return resourceVersion, runSynced(&c.lock, func() error { + c.replaceResourceCache(api.GroupKind, items, ns) + return nil + }) + } + c.replaceResourceCache(api.GroupKind, items, ns) + return resourceVersion, nil +} + +func (c *clusterCache) watchEvents(ctx context.Context, api kube.APIResourceInfo, resClient dynamic.ResourceInterface, ns string, resourceVersion string) { + kube.RetryUntilSucceed(ctx, watchResourcesRetryTimeout, fmt.Sprintf("watch %s on %s", api.GroupKind, c.config.Host), c.log, func() (err error) { + defer func() { + if r := recover(); r != nil { + err = fmt.Errorf("recovered from panic: %+v\n%s", r, debug.Stack()) + } + }() + + // load API initial state if no resource version provided + if resourceVersion == "" { + resourceVersion, err = c.loadInitialState(ctx, api, resClient, ns, true) + if err != nil { + return err + } + } + + w, err := watchutil.NewRetryWatcherWithContext(ctx, resourceVersion, &cache.ListWatch{ + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + res, err := resClient.Watch(ctx, options) + if apierrors.IsNotFound(err) { + c.stopWatching(api.GroupKind, ns) + } + //nolint:wrapcheck // wrap outside the retry + return res, err + }, + }) + if err != nil { + return fmt.Errorf("failed to create resource watcher: %w", err) + } + + defer func() { + w.Stop() + resourceVersion = "" + }() + + var watchResyncTimeoutCh <-chan time.Time + if c.watchResyncTimeout > 0 { + shouldResync := time.NewTimer(c.watchResyncTimeout) + defer shouldResync.Stop() + watchResyncTimeoutCh = shouldResync.C + } + + for { + select { + // stop watching when parent context got cancelled + case <-ctx.Done(): + return nil + + // re-synchronize API state and restart watch periodically + case <-watchResyncTimeoutCh: + return fmt.Errorf("resyncing %s on %s due to timeout", api.GroupKind, c.config.Host) + + // re-synchronize API state and restart watch if retry watcher failed to continue watching using provided resource version + case <-w.Done(): + return fmt.Errorf("watch %s on %s has closed", api.GroupKind, c.config.Host) + + case event, ok := <-w.ResultChan(): + if !ok { + return fmt.Errorf("watch %s on %s has closed", api.GroupKind, c.config.Host) + } + + obj, ok := event.Object.(*unstructured.Unstructured) + if !ok { + return fmt.Errorf("failed to convert to *unstructured.Unstructured: %v", event.Object) + } + + c.recordEvent(event.Type, obj) + if kube.IsCRD(obj) { + var resources []kube.APIResourceInfo + crd := apiextensionsv1.CustomResourceDefinition{} + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &crd) + if err != nil { + c.log.Error(err, "Failed to extract CRD resources") + } + for _, v := range crd.Spec.Versions { + resources = append(resources, kube.APIResourceInfo{ + GroupKind: schema.GroupKind{ + Group: crd.Spec.Group, Kind: crd.Spec.Names.Kind, + }, + GroupVersionResource: schema.GroupVersionResource{ + Group: crd.Spec.Group, Version: v.Name, Resource: crd.Spec.Names.Plural, + }, + Meta: metav1.APIResource{ + Group: crd.Spec.Group, + SingularName: crd.Spec.Names.Singular, + Namespaced: crd.Spec.Scope == apiextensionsv1.NamespaceScoped, + Name: crd.Spec.Names.Plural, + Kind: crd.Spec.Names.Singular, + Version: v.Name, + ShortNames: crd.Spec.Names.ShortNames, + }, + }) + } + + if event.Type == watch.Deleted { + for i := range resources { + c.deleteAPIResource(resources[i]) + } + } else { + c.log.Info("Updating Kubernetes APIs, watches, and Open API schemas due to CRD event", "eventType", event.Type, "groupKind", crd.GroupVersionKind().GroupKind().String()) + // add new CRD's groupkind to c.apigroups + if event.Type == watch.Added { + for i := range resources { + c.appendAPIResource(resources[i]) + } + } + err = runSynced(&c.lock, func() error { + return c.startMissingWatches() + }) + if err != nil { + c.log.Error(err, "Failed to start missing watch") + } + } + err = runSynced(&c.lock, func() error { + openAPISchema, gvkParser, err := c.kubectl.LoadOpenAPISchema(c.config) + if err != nil { + return fmt.Errorf("failed to load open api schema while handling CRD change: %w", err) + } + if gvkParser != nil { + c.gvkParser = gvkParser + } + c.openAPISchema = openAPISchema + return nil + }) + if err != nil { + c.log.Error(err, "Failed to reload open api schema") + } + } + } + } + }) +} + +// processApi processes all the resources for a given API. First we construct an API client for the given API. Then we +// call the callback. If we're managing the whole cluster, we call the callback with the client and an empty namespace. +// If we're managing specific namespaces, we call the callback for each namespace. +func (c *clusterCache) processApi(client dynamic.Interface, api kube.APIResourceInfo, callback func(resClient dynamic.ResourceInterface, ns string) error) error { + resClient := client.Resource(api.GroupVersionResource) + switch { + // if manage whole cluster or resource is cluster level and cluster resources enabled + case len(c.namespaces) == 0 || (!api.Meta.Namespaced && c.clusterResources): + return callback(resClient, "") + // if manage some namespaces and resource is namespaced + case len(c.namespaces) != 0 && api.Meta.Namespaced: + for _, ns := range c.namespaces { + err := callback(resClient.Namespace(ns), ns) + if err != nil { + return err + } + } + } + + return nil +} + +// isRestrictedResource checks if the kube api call is unauthorized or forbidden +func (c *clusterCache) isRestrictedResource(err error) bool { + return c.respectRBAC != RespectRbacDisabled && (apierrors.IsForbidden(err) || apierrors.IsUnauthorized(err)) +} + +// checkPermission runs a self subject access review to check if the controller has permissions to list the resource +func (c *clusterCache) checkPermission(ctx context.Context, reviewInterface authType1.SelfSubjectAccessReviewInterface, api kube.APIResourceInfo) (keep bool, err error) { + sar := &authorizationv1.SelfSubjectAccessReview{ + Spec: authorizationv1.SelfSubjectAccessReviewSpec{ + ResourceAttributes: &authorizationv1.ResourceAttributes{ + Namespace: "*", + Verb: "list", // uses list verb to check for permissions + Resource: api.GroupVersionResource.Resource, + }, + }, + } + + switch { + // if manage whole cluster or resource is cluster level and cluster resources enabled + case len(c.namespaces) == 0 || (!api.Meta.Namespaced && c.clusterResources): + resp, err := reviewInterface.Create(ctx, sar, metav1.CreateOptions{}) + if err != nil { + return false, fmt.Errorf("failed to create self subject access review: %w", err) + } + if resp != nil && resp.Status.Allowed { + return true, nil + } + // unsupported, remove from watch list + return false, nil + // if manage some namespaces and resource is namespaced + case len(c.namespaces) != 0 && api.Meta.Namespaced: + for _, ns := range c.namespaces { + sar.Spec.ResourceAttributes.Namespace = ns + resp, err := reviewInterface.Create(ctx, sar, metav1.CreateOptions{}) + if err != nil { + return false, fmt.Errorf("failed to create self subject access review: %w", err) + } + if resp != nil && resp.Status.Allowed { + return true, nil + } + // unsupported, remove from watch list + //nolint:staticcheck //FIXME + return false, nil + } + } + // checkPermission follows the same logic of determining namespace/cluster resource as the processApi function + // so if neither of the cases match it means the controller will not watch for it so it is safe to return true. + return true, nil +} + +// sync retrieves the current state of the cluster and stores relevant information in the clusterCache fields. +// +// First we get some metadata from the cluster, like the server version, OpenAPI document, and the list of all API +// resources. +// +// Then we get a list of the preferred versions of all API resources which are to be monitored (it's possible to exclude +// resources from monitoring). We loop through those APIs asynchronously and for each API we list all resources. We also +// kick off a goroutine to watch the resources for that API and update the cache constantly. +// +// When this function exits, the cluster cache is up to date, and the appropriate resources are being watched for +// changes. +func (c *clusterCache) sync() error { + c.log.Info("Start syncing cluster") + + for i := range c.apisMeta { + c.apisMeta[i].watchCancel() + } + + if c.batchEventsProcessing { + c.invalidateEventMeta() + c.eventMetaCh = make(chan eventMeta) + } + + c.apisMeta = make(map[schema.GroupKind]*apiMeta) + c.resources = make(map[kube.ResourceKey]*Resource) + c.namespacedResources = make(map[schema.GroupKind]bool) + config := c.config + version, err := c.kubectl.GetServerVersion(config) + if err != nil { + return fmt.Errorf("failed to get server version: %w", err) + } + c.serverVersion = version + apiResources, err := c.kubectl.GetAPIResources(config, false, NewNoopSettings()) + if err != nil { + return fmt.Errorf("failed to get api resources: %w", err) + } + c.apiResources = apiResources + + openAPISchema, gvkParser, err := c.kubectl.LoadOpenAPISchema(config) + if err != nil { + return fmt.Errorf("failed to load open api schema while syncing cluster cache: %w", err) + } + + if gvkParser != nil { + c.gvkParser = gvkParser + } + + c.openAPISchema = openAPISchema + + apis, err := c.kubectl.GetAPIResources(c.config, true, c.settings.ResourcesFilter) + if err != nil { + return fmt.Errorf("failed to get api resources: %w", err) + } + client, err := c.kubectl.NewDynamicClient(c.config) + if err != nil { + return fmt.Errorf("failed to create client: %w", err) + } + clientset, err := kubernetes.NewForConfig(config) + if err != nil { + return fmt.Errorf("failed to create clientset: %w", err) + } + + if c.batchEventsProcessing { + go c.processEvents() + } + + // Each API is processed in parallel, so we need to take out a lock when we update clusterCache fields. + lock := sync.Mutex{} + err = kube.RunAllAsync(len(apis), func(i int) error { + api := apis[i] + + lock.Lock() + ctx, cancel := context.WithCancel(context.Background()) + info := &apiMeta{namespaced: api.Meta.Namespaced, watchCancel: cancel} + c.apisMeta[api.GroupKind] = info + c.namespacedResources[api.GroupKind] = api.Meta.Namespaced + lock.Unlock() + + return c.processApi(client, api, func(resClient dynamic.ResourceInterface, ns string) error { + resourceVersion, err := c.listResources(ctx, resClient, func(listPager *pager.ListPager) error { + return listPager.EachListItem(context.Background(), metav1.ListOptions{}, func(obj runtime.Object) error { + if un, ok := obj.(*unstructured.Unstructured); !ok { + return fmt.Errorf("object %s/%s has an unexpected type", un.GroupVersionKind().String(), un.GetName()) + } else { + newRes := c.newResource(un) + lock.Lock() + c.setNode(newRes) + lock.Unlock() + } + return nil + }) + }) + if err != nil { + if c.isRestrictedResource(err) { + keep := false + if c.respectRBAC == RespectRbacStrict { + k, permErr := c.checkPermission(ctx, clientset.AuthorizationV1().SelfSubjectAccessReviews(), api) + if permErr != nil { + return fmt.Errorf("failed to check permissions for resource %s: %w, original error=%v", api.GroupKind.String(), permErr, err.Error()) + } + keep = k + } + // if we are not allowed to list the resource, remove it from the watch list + if !keep { + lock.Lock() + delete(c.apisMeta, api.GroupKind) + delete(c.namespacedResources, api.GroupKind) + lock.Unlock() + return nil + } + } + return fmt.Errorf("failed to load initial state of resource %s: %w", api.GroupKind.String(), err) + } + + go c.watchEvents(ctx, api, resClient, ns, resourceVersion) + + return nil + }) + }) + if err != nil { + c.log.Error(err, "Failed to sync cluster") + return fmt.Errorf("failed to sync cluster %s: %w", c.config.Host, err) + } + + c.log.Info("Cluster successfully synced") + return nil +} + +// invalidateEventMeta closes the eventMeta channel if it is open +func (c *clusterCache) invalidateEventMeta() { + if c.eventMetaCh != nil { + close(c.eventMetaCh) + c.eventMetaCh = nil + } +} + +// EnsureSynced checks cache state and synchronizes it if necessary +func (c *clusterCache) EnsureSynced() error { + syncStatus := &c.syncStatus + + // first check if cluster is synced *without acquiring the full clusterCache lock* + syncStatus.lock.Lock() + if syncStatus.synced(c.clusterSyncRetryTimeout) { + syncError := syncStatus.syncError + syncStatus.lock.Unlock() + return syncError + } + syncStatus.lock.Unlock() // release the lock, so that we can acquire the parent lock (see struct comment re: lock acquisition ordering) + + c.lock.Lock() + defer c.lock.Unlock() + syncStatus.lock.Lock() + defer syncStatus.lock.Unlock() + + // before doing any work, check once again now that we have the lock, to see if it got + // synced between the first check and now + if syncStatus.synced(c.clusterSyncRetryTimeout) { + return syncStatus.syncError + } + err := c.sync() + syncTime := time.Now() + syncStatus.syncTime = &syncTime + syncStatus.syncError = err + return syncStatus.syncError +} + +func (c *clusterCache) FindResources(namespace string, predicates ...func(r *Resource) bool) map[kube.ResourceKey]*Resource { + c.lock.RLock() + defer c.lock.RUnlock() + result := map[kube.ResourceKey]*Resource{} + resources := map[kube.ResourceKey]*Resource{} + if namespace != "" { + if ns, ok := c.nsIndex[namespace]; ok { + resources = ns + } + } else { + resources = c.resources + } + + for k := range resources { + r := resources[k] + matches := true + for i := range predicates { + if !predicates[i](r) { + matches = false + break + } + } + + if matches { + result[k] = r + } + } + return result +} + +// IterateHierarchy iterates resource tree starting from the specified top level resources and executes callback for each resource in the tree +func (c *clusterCache) IterateHierarchyV2(keys []kube.ResourceKey, action func(resource *Resource, namespaceResources map[kube.ResourceKey]*Resource) bool) { + c.lock.RLock() + defer c.lock.RUnlock() + keysPerNamespace := make(map[string][]kube.ResourceKey) + for _, key := range keys { + _, ok := c.resources[key] + if !ok { + continue + } + keysPerNamespace[key.Namespace] = append(keysPerNamespace[key.Namespace], key) + } + for namespace, namespaceKeys := range keysPerNamespace { + nsNodes := c.nsIndex[namespace] + graph := buildGraph(nsNodes) + visited := make(map[kube.ResourceKey]int) + for _, key := range namespaceKeys { + visited[key] = 0 + } + for _, key := range namespaceKeys { + // The check for existence of key is done above. + res := c.resources[key] + if visited[key] == 2 || !action(res, nsNodes) { + continue + } + visited[key] = 1 + if _, ok := graph[key]; ok { + for _, child := range graph[key] { + if visited[child.ResourceKey()] == 0 && action(child, nsNodes) { + child.iterateChildrenV2(graph, nsNodes, visited, func(err error, child *Resource, namespaceResources map[kube.ResourceKey]*Resource) bool { + if err != nil { + c.log.V(2).Info(err.Error()) + return false + } + return action(child, namespaceResources) + }) + } + } + } + visited[key] = 2 + } + } +} + +func buildGraph(nsNodes map[kube.ResourceKey]*Resource) map[kube.ResourceKey]map[types.UID]*Resource { + // Prepare to construct a graph + nodesByUID := make(map[types.UID][]*Resource, len(nsNodes)) + for _, node := range nsNodes { + nodesByUID[node.Ref.UID] = append(nodesByUID[node.Ref.UID], node) + } + + // In graph, they key is the parent and the value is a list of children. + graph := make(map[kube.ResourceKey]map[types.UID]*Resource) + + // Loop through all nodes, calling each one "childNode," because we're only bothering with it if it has a parent. + for _, childNode := range nsNodes { + for i, ownerRef := range childNode.OwnerRefs { + // First, backfill UID of inferred owner child references. + if ownerRef.UID == "" { + group, err := schema.ParseGroupVersion(ownerRef.APIVersion) + if err != nil { + // APIVersion is invalid, so we couldn't find the parent. + continue + } + graphKeyNode, ok := nsNodes[kube.ResourceKey{Group: group.Group, Kind: ownerRef.Kind, Namespace: childNode.Ref.Namespace, Name: ownerRef.Name}] + if !ok { + // No resource found with the given graph key, so move on. + continue + } + ownerRef.UID = graphKeyNode.Ref.UID + childNode.OwnerRefs[i] = ownerRef + } + + // Now that we have the UID of the parent, update the graph. + uidNodes, ok := nodesByUID[ownerRef.UID] + if ok { + for _, uidNode := range uidNodes { + // Update the graph for this owner to include the child. + if _, ok := graph[uidNode.ResourceKey()]; !ok { + graph[uidNode.ResourceKey()] = make(map[types.UID]*Resource) + } + r, ok := graph[uidNode.ResourceKey()][childNode.Ref.UID] + if !ok { + graph[uidNode.ResourceKey()][childNode.Ref.UID] = childNode + } else if r != nil { + // The object might have multiple children with the same UID (e.g. replicaset from apps and extensions group). + // It is ok to pick any object, but we need to make sure we pick the same child after every refresh. + key1 := r.ResourceKey() + key2 := childNode.ResourceKey() + if strings.Compare(key1.String(), key2.String()) > 0 { + graph[uidNode.ResourceKey()][childNode.Ref.UID] = childNode + } + } + } + } + } + } + return graph +} + +// IsNamespaced answers if specified group/kind is a namespaced resource API or not +func (c *clusterCache) IsNamespaced(gk schema.GroupKind) (bool, error) { + if isNamespaced, ok := c.namespacedResources[gk]; ok { + return isNamespaced, nil + } + return false, apierrors.NewNotFound(schema.GroupResource{Group: gk.Group}, "") +} + +func (c *clusterCache) managesNamespace(namespace string) bool { + for _, ns := range c.namespaces { + if ns == namespace { + return true + } + } + return false +} + +// GetManagedLiveObjs helps finding matching live K8S resources for a given resources list. +// The function returns all resources from cache for those `isManaged` function returns true and resources +// specified in targetObjs list. +func (c *clusterCache) GetManagedLiveObjs(targetObjs []*unstructured.Unstructured, isManaged func(r *Resource) bool) (map[kube.ResourceKey]*unstructured.Unstructured, error) { + c.lock.RLock() + defer c.lock.RUnlock() + + for _, o := range targetObjs { + if len(c.namespaces) > 0 { + if o.GetNamespace() == "" && !c.clusterResources { + return nil, fmt.Errorf("cluster level %s %q can not be managed when in namespaced mode", o.GetKind(), o.GetName()) + } else if o.GetNamespace() != "" && !c.managesNamespace(o.GetNamespace()) { + return nil, fmt.Errorf("namespace %q for %s %q is not managed", o.GetNamespace(), o.GetKind(), o.GetName()) + } + } + } + + managedObjs := make(map[kube.ResourceKey]*unstructured.Unstructured) + // iterate all objects in live state cache to find ones associated with app + for key, o := range c.resources { + if isManaged(o) && o.Resource != nil && len(o.OwnerRefs) == 0 { + managedObjs[key] = o.Resource + } + } + // but are simply missing our label + lock := &sync.Mutex{} + err := kube.RunAllAsync(len(targetObjs), func(i int) error { + targetObj := targetObjs[i] + key := kube.GetResourceKey(targetObj) + lock.Lock() + managedObj := managedObjs[key] + lock.Unlock() + + if managedObj == nil { + if existingObj, exists := c.resources[key]; exists { + if existingObj.Resource != nil { + managedObj = existingObj.Resource + } else { + var err error + managedObj, err = c.kubectl.GetResource(context.TODO(), c.config, targetObj.GroupVersionKind(), existingObj.Ref.Name, existingObj.Ref.Namespace) + if err != nil { + if apierrors.IsNotFound(err) { + return nil + } + return fmt.Errorf("unexpected error getting managed object: %w", err) + } + } + } else if _, watched := c.apisMeta[key.GroupKind()]; !watched { + var err error + managedObj, err = c.kubectl.GetResource(context.TODO(), c.config, targetObj.GroupVersionKind(), targetObj.GetName(), targetObj.GetNamespace()) + if err != nil { + if apierrors.IsNotFound(err) { + return nil + } + return fmt.Errorf("unexpected error getting managed object: %w", err) + } + } + } + + if managedObj != nil { + converted, err := c.kubectl.ConvertToVersion(managedObj, targetObj.GroupVersionKind().Group, targetObj.GroupVersionKind().Version) + if err != nil { + // fallback to loading resource from kubernetes if conversion fails + c.log.V(1).Info(fmt.Sprintf("Failed to convert resource: %v", err)) + managedObj, err = c.kubectl.GetResource(context.TODO(), c.config, targetObj.GroupVersionKind(), managedObj.GetName(), managedObj.GetNamespace()) + if err != nil { + if apierrors.IsNotFound(err) { + return nil + } + return fmt.Errorf("unexpected error getting managed object: %w", err) + } + } else { + managedObj = converted + } + lock.Lock() + managedObjs[key] = managedObj + lock.Unlock() + } + return nil + }) + if err != nil { + return nil, fmt.Errorf("failed to get managed objects: %w", err) + } + + return managedObjs, nil +} + +func (c *clusterCache) recordEvent(event watch.EventType, un *unstructured.Unstructured) { + for _, h := range c.getEventHandlers() { + h(event, un) + } + key := kube.GetResourceKey(un) + if event == watch.Modified && skipAppRequeuing(key) { + return + } + + if c.batchEventsProcessing { + c.eventMetaCh <- eventMeta{event, un} + } else { + c.lock.Lock() + defer c.lock.Unlock() + c.processEvent(key, eventMeta{event, un}) + } +} + +func (c *clusterCache) processEvents() { + log := c.log.WithValues("functionName", "processItems") + log.V(1).Info("Start processing events") + + c.lock.Lock() + ch := c.eventMetaCh + c.lock.Unlock() + + eventMetas := make([]eventMeta, 0) + ticker := time.NewTicker(c.eventProcessingInterval) + defer ticker.Stop() + + for { + select { + case evMeta, ok := <-ch: + if !ok { + log.V(2).Info("Event processing channel closed, finish processing") + return + } + eventMetas = append(eventMetas, evMeta) + case <-ticker.C: + if len(eventMetas) > 0 { + c.processEventsBatch(eventMetas) + eventMetas = eventMetas[:0] + } + } + } +} + +func (c *clusterCache) processEventsBatch(eventMetas []eventMeta) { + log := c.log.WithValues("functionName", "processEventsBatch") + start := time.Now() + c.lock.Lock() + log.V(1).Info("Lock acquired (ms)", "duration", time.Since(start).Milliseconds()) + defer func() { + c.lock.Unlock() + duration := time.Since(start) + // Update the metric with the duration of the events processing + for _, handler := range c.getProcessEventsHandlers() { + handler(duration, len(eventMetas)) + } + }() + + for _, evMeta := range eventMetas { + key := kube.GetResourceKey(evMeta.un) + c.processEvent(key, evMeta) + } + + log.V(1).Info("Processed events (ms)", "count", len(eventMetas), "duration", time.Since(start).Milliseconds()) +} + +func (c *clusterCache) processEvent(key kube.ResourceKey, evMeta eventMeta) { + existingNode, exists := c.resources[key] + if evMeta.event == watch.Deleted { + if exists { + c.onNodeRemoved(key) + } + } else { + c.onNodeUpdated(existingNode, c.newResource(evMeta.un)) + } +} + +func (c *clusterCache) onNodeUpdated(oldRes *Resource, newRes *Resource) { + c.setNode(newRes) + for _, h := range c.getResourceUpdatedHandlers() { + h(newRes, oldRes, c.nsIndex[newRes.Ref.Namespace]) + } +} + +func (c *clusterCache) onNodeRemoved(key kube.ResourceKey) { + existing, ok := c.resources[key] + if ok { + delete(c.resources, key) + ns, ok := c.nsIndex[key.Namespace] + if ok { + delete(ns, key) + if len(ns) == 0 { + delete(c.nsIndex, key.Namespace) + } + // remove ownership references from children with inferred references + if existing.isInferredParentOf != nil { + for k, v := range ns { + if mightHaveInferredOwner(v) && existing.isInferredParentOf(k) { + v.setOwnerRef(existing.toOwnerRef(), false) + } + } + } + } + for _, h := range c.getResourceUpdatedHandlers() { + h(nil, existing, ns) + } + } +} + +var ignoredRefreshResources = map[string]bool{ + "/" + kube.EndpointsKind: true, +} + +// GetClusterInfo returns cluster cache statistics +func (c *clusterCache) GetClusterInfo() ClusterInfo { + c.lock.RLock() + defer c.lock.RUnlock() + c.syncStatus.lock.Lock() + defer c.syncStatus.lock.Unlock() + + return ClusterInfo{ + APIsCount: len(c.apisMeta), + K8SVersion: c.serverVersion, + ResourcesCount: len(c.resources), + Server: c.config.Host, + LastCacheSyncTime: c.syncStatus.syncTime, + SyncError: c.syncStatus.syncError, + APIResources: c.apiResources, + } +} + +// skipAppRequeuing checks if the object is an API type which we want to skip requeuing against. +// We ignore API types which have a high churn rate, and/or whose updates are irrelevant to the app +func skipAppRequeuing(key kube.ResourceKey) bool { + return ignoredRefreshResources[key.Group+"/"+key.Kind] +} diff --git a/gitops-engine/pkg/cache/cluster_test.go b/gitops-engine/pkg/cache/cluster_test.go new file mode 100644 index 0000000000000..7bac780439d29 --- /dev/null +++ b/gitops-engine/pkg/cache/cluster_test.go @@ -0,0 +1,1294 @@ +package cache + +import ( + "context" + "errors" + "fmt" + "sort" + "strings" + "sync" + "testing" + "time" + + "golang.org/x/sync/semaphore" + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/dynamic/fake" + "k8s.io/client-go/kubernetes/scheme" + "k8s.io/client-go/rest" + testcore "k8s.io/client-go/testing" + "sigs.k8s.io/yaml" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/kube/kubetest" +) + +func mustToUnstructured(obj any) *unstructured.Unstructured { + un, err := kube.ToUnstructured(obj) + if err != nil { + panic(err) + } + return un +} + +func strToUnstructured(jsonStr string) *unstructured.Unstructured { + obj := make(map[string]any) + err := yaml.Unmarshal([]byte(jsonStr), &obj) + if err != nil { + panic(err) + } + return &unstructured.Unstructured{Object: obj} +} + +var ( + testCreationTime, _ = time.Parse(time.RFC3339, "2018-09-20T06:47:27Z") + + testService = strToUnstructured(fmt.Sprintf(` + apiVersion: v1 + kind: Service + metadata: + name: helm-guestbook + namespace: default + resourceVersion: "123" + uid: "4" + creationTimestamp: "%s" + spec: + selector: + app: guestbook + type: LoadBalancer + status: + loadBalancer: + ingress: + - hostname: localhost`, testCreationTime.UTC().Format(time.RFC3339))) +) + +func newCluster(tb testing.TB, objs ...runtime.Object) *clusterCache { + tb.Helper() + cache := newClusterWithOptions(tb, []UpdateSettingsFunc{}, objs...) + + tb.Cleanup(func() { + cache.Invalidate() + }) + + return cache +} + +func newClusterWithOptions(_ testing.TB, opts []UpdateSettingsFunc, objs ...runtime.Object) *clusterCache { + client := fake.NewSimpleDynamicClient(scheme.Scheme, objs...) + reactor := client.ReactionChain[0] + client.PrependReactor("list", "*", func(action testcore.Action) (handled bool, ret runtime.Object, err error) { + handled, ret, err = reactor.React(action) + if err != nil || !handled { + return + } + // make sure list response have resource version + ret.(metav1.ListInterface).SetResourceVersion("123") + return + }) + + apiResources := []kube.APIResourceInfo{{ + GroupKind: schema.GroupKind{Group: "", Kind: "Pod"}, + GroupVersionResource: schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}, + Meta: metav1.APIResource{Namespaced: true}, + }, { + GroupKind: schema.GroupKind{Group: "apps", Kind: "ReplicaSet"}, + GroupVersionResource: schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "replicasets"}, + Meta: metav1.APIResource{Namespaced: true}, + }, { + GroupKind: schema.GroupKind{Group: "apps", Kind: "Deployment"}, + GroupVersionResource: schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}, + Meta: metav1.APIResource{Namespaced: true}, + }, { + GroupKind: schema.GroupKind{Group: "apps", Kind: "StatefulSet"}, + GroupVersionResource: schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "statefulsets"}, + Meta: metav1.APIResource{Namespaced: true}, + }, { + GroupKind: schema.GroupKind{Group: "extensions", Kind: "ReplicaSet"}, + GroupVersionResource: schema.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "replicasets"}, + Meta: metav1.APIResource{Namespaced: true}, + }} + + opts = append([]UpdateSettingsFunc{ + SetKubectl(&kubetest.MockKubectlCmd{APIResources: apiResources, DynamicClient: client}), + }, opts...) + + cache := NewClusterCache( + &rest.Config{Host: "https://test"}, + opts..., + ) + return cache +} + +func (c *clusterCache) WithAPIResources(newApiResources []kube.APIResourceInfo) *clusterCache { + apiResources := c.kubectl.(*kubetest.MockKubectlCmd).APIResources + apiResources = append(apiResources, newApiResources...) + c.kubectl.(*kubetest.MockKubectlCmd).APIResources = apiResources + return c +} + +func getChildren(cluster *clusterCache, un *unstructured.Unstructured) []*Resource { + hierarchy := make([]*Resource, 0) + cluster.IterateHierarchyV2([]kube.ResourceKey{kube.GetResourceKey(un)}, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + hierarchy = append(hierarchy, child) + return true + }) + return hierarchy[1:] +} + +// Benchmark_sync is meant to simulate cluster initialization when populateResourceInfoHandler does nontrivial work. +func Benchmark_sync(t *testing.B) { + resources := []runtime.Object{} + for i := 0; i < 100; i++ { + resources = append(resources, &corev1.Pod{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("pod-%d", i), + Namespace: "default", + }, + }, &appsv1.ReplicaSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("rs-%d", i), + Namespace: "default", + }, + }, &appsv1.Deployment{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("deploy-%d", i), + Namespace: "default", + }, + }, &appsv1.StatefulSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("sts-%d", i), + Namespace: "default", + }, + }) + } + + c := newCluster(t, resources...) + + c.populateResourceInfoHandler = func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + time.Sleep(10 * time.Microsecond) + return nil, false + } + + t.ResetTimer() + + for n := 0; n < t.N; n++ { + err := c.sync() + require.NoError(t, err) + } +} + +func TestEnsureSynced(t *testing.T) { + obj1 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook1", + Namespace: "default1", + }, + } + obj2 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook2", + Namespace: "default2", + }, + } + + cluster := newCluster(t, obj1, obj2) + err := cluster.EnsureSynced() + require.NoError(t, err) + + cluster.lock.Lock() + defer cluster.lock.Unlock() + + assert.Len(t, cluster.resources, 2) + var names []string + for k := range cluster.resources { + names = append(names, k.Name) + } + assert.ElementsMatch(t, []string{"helm-guestbook1", "helm-guestbook2"}, names) +} + +func TestStatefulSetOwnershipInferred(t *testing.T) { + var opts []UpdateSettingsFunc + opts = append(opts, func(c *clusterCache) { + c.batchEventsProcessing = true + c.eventProcessingInterval = 1 * time.Millisecond + }) + + sts := &appsv1.StatefulSet{ + TypeMeta: metav1.TypeMeta{APIVersion: "apps/v1", Kind: kube.StatefulSetKind}, + ObjectMeta: metav1.ObjectMeta{UID: "123", Name: "web", Namespace: "default"}, + Spec: appsv1.StatefulSetSpec{ + VolumeClaimTemplates: []corev1.PersistentVolumeClaim{{ + ObjectMeta: metav1.ObjectMeta{ + Name: "www", + }, + }}, + }, + } + + tests := []struct { + name string + cluster *clusterCache + pvc *corev1.PersistentVolumeClaim + expectedRefs []metav1.OwnerReference + expectNoOwner bool + }{ + { + name: "STSTemplateNameNotMatching", + cluster: newCluster(t, sts), + pvc: &corev1.PersistentVolumeClaim{ + TypeMeta: metav1.TypeMeta{Kind: kube.PersistentVolumeClaimKind}, + ObjectMeta: metav1.ObjectMeta{Name: "www1-web-0", Namespace: "default"}, + }, + expectNoOwner: true, + }, + { + name: "MatchingSTSExists", + cluster: newCluster(t, sts), + pvc: &corev1.PersistentVolumeClaim{ + TypeMeta: metav1.TypeMeta{Kind: kube.PersistentVolumeClaimKind}, + ObjectMeta: metav1.ObjectMeta{Name: "www-web-0", Namespace: "default"}, + }, + expectedRefs: []metav1.OwnerReference{{APIVersion: "apps/v1", Kind: kube.StatefulSetKind, Name: "web", UID: "123"}}, + }, + { + name: "STSTemplateNameNotMatchingWithBatchProcessing", + cluster: newClusterWithOptions(t, opts, sts), + pvc: &corev1.PersistentVolumeClaim{ + TypeMeta: metav1.TypeMeta{Kind: kube.PersistentVolumeClaimKind}, + ObjectMeta: metav1.ObjectMeta{Name: "www1-web-0", Namespace: "default"}, + }, + expectNoOwner: true, + }, + { + name: "MatchingSTSExistsWithBatchProcessing", + cluster: newClusterWithOptions(t, opts, sts), + pvc: &corev1.PersistentVolumeClaim{ + TypeMeta: metav1.TypeMeta{Kind: kube.PersistentVolumeClaimKind}, + ObjectMeta: metav1.ObjectMeta{Name: "www-web-0", Namespace: "default"}, + }, + expectedRefs: []metav1.OwnerReference{{APIVersion: "apps/v1", Kind: kube.StatefulSetKind, Name: "web", UID: "123"}}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + err := tc.cluster.EnsureSynced() + require.NoError(t, err) + + pvc := mustToUnstructured(tc.pvc) + tc.cluster.recordEvent(watch.Added, pvc) + + require.Eventually(t, func() bool { + tc.cluster.lock.Lock() + defer tc.cluster.lock.Unlock() + + refs := tc.cluster.resources[kube.GetResourceKey(pvc)].OwnerRefs + if tc.expectNoOwner { + return len(refs) == 0 + } + return assert.ElementsMatch(t, refs, tc.expectedRefs) + }, 5*time.Second, 10*time.Millisecond, "Expected PVC to have correct owner reference") + }) + } +} + +func TestEnsureSyncedSingleNamespace(t *testing.T) { + obj1 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook1", + Namespace: "default1", + }, + } + obj2 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook2", + Namespace: "default2", + }, + } + + cluster := newCluster(t, obj1, obj2) + cluster.namespaces = []string{"default1"} + err := cluster.EnsureSynced() + require.NoError(t, err) + + cluster.lock.Lock() + defer cluster.lock.Unlock() + + assert.Len(t, cluster.resources, 1) + var names []string + for k := range cluster.resources { + names = append(names, k.Name) + } + assert.ElementsMatch(t, []string{"helm-guestbook1"}, names) +} + +func TestGetChildren(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + err := cluster.EnsureSynced() + require.NoError(t, err) + + rsChildren := getChildren(cluster, mustToUnstructured(testRS())) + assert.Equal(t, []*Resource{{ + Ref: corev1.ObjectReference{ + Kind: "Pod", + Namespace: "default", + Name: "helm-guestbook-pod-1", + APIVersion: "v1", + UID: "1", + }, + OwnerRefs: []metav1.OwnerReference{{ + APIVersion: "apps/v1", + Kind: "ReplicaSet", + Name: "helm-guestbook-rs", + UID: "2", + }}, + ResourceVersion: "123", + CreationTimestamp: &metav1.Time{ + Time: testCreationTime.Local(), + }, + }}, rsChildren) + deployChildren := getChildren(cluster, mustToUnstructured(testDeploy())) + + assert.Equal(t, append([]*Resource{{ + Ref: corev1.ObjectReference{ + Kind: "ReplicaSet", + Namespace: "default", + Name: "helm-guestbook-rs", + APIVersion: "apps/v1", + UID: "2", + }, + ResourceVersion: "123", + OwnerRefs: []metav1.OwnerReference{{APIVersion: "apps/v1beta1", Kind: "Deployment", Name: "helm-guestbook", UID: "3"}}, + CreationTimestamp: &metav1.Time{ + Time: testCreationTime.Local(), + }, + }}, rsChildren...), deployChildren) +} + +func TestGetManagedLiveObjs(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + + err := cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + labels: + app: helm-guestbook`) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + require.NoError(t, err) + assert.Equal(t, map[kube.ResourceKey]*unstructured.Unstructured{ + kube.NewResourceKey("apps", "Deployment", "default", "helm-guestbook"): mustToUnstructured(testDeploy()), + }, managedObjs) +} + +func TestGetManagedLiveObjsNamespacedModeClusterLevelResource(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = []string{"default", "production"} + + err := cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + labels: + app: helm-guestbook`) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + assert.Nil(t, managedObjs) + assert.EqualError(t, err, "cluster level Deployment \"helm-guestbook\" can not be managed when in namespaced mode") +} + +func TestGetManagedLiveObjsNamespacedModeClusterLevelResource_ClusterResourceEnabled(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = []string{"default", "production"} + cluster.clusterResources = true + + err := cluster.EnsureSynced() + require.NoError(t, err) + + clusterLevelRes := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + labels: + app: helm-guestbook`) + + cluster.clusterResources = true + _, err = cluster.GetManagedLiveObjs([]*unstructured.Unstructured{clusterLevelRes}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + require.NoError(t, err) + + otherNamespaceRes := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + namespace: some-other-namespace + labels: + app: helm-guestbook`) + + cluster.clusterResources = true + _, err = cluster.GetManagedLiveObjs([]*unstructured.Unstructured{otherNamespaceRes}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + assert.EqualError(t, err, "namespace \"some-other-namespace\" for Deployment \"helm-guestbook\" is not managed") +} + +func TestGetManagedLiveObjsAllNamespaces(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = nil + + err := cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + namespace: production + labels: + app: helm-guestbook`) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + require.NoError(t, err) + assert.Equal(t, map[kube.ResourceKey]*unstructured.Unstructured{ + kube.NewResourceKey("apps", "Deployment", "default", "helm-guestbook"): mustToUnstructured(testDeploy()), + }, managedObjs) +} + +func TestGetManagedLiveObjsValidNamespace(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = []string{"default", "production"} + + err := cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + namespace: production + labels: + app: helm-guestbook`) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + require.NoError(t, err) + assert.Equal(t, map[kube.ResourceKey]*unstructured.Unstructured{ + kube.NewResourceKey("apps", "Deployment", "default", "helm-guestbook"): mustToUnstructured(testDeploy()), + }, managedObjs) +} + +func TestGetManagedLiveObjsInvalidNamespace(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = []string{"default", "develop"} + + err := cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: helm-guestbook + namespace: production + labels: + app: helm-guestbook`) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(r *Resource) bool { + return len(r.OwnerRefs) == 0 + }) + assert.Nil(t, managedObjs) + assert.EqualError(t, err, "namespace \"production\" for Deployment \"helm-guestbook\" is not managed") +} + +func TestGetManagedLiveObjsFailedConversion(t *testing.T) { + cronTabGroup := "stable.example.com" + + testCases := []struct { + name string + localConvertFails bool + expectConvertToVersionCalled bool + expectGetResourceCalled bool + }{ + { + name: "local convert fails, so GetResource is called", + localConvertFails: true, + expectConvertToVersionCalled: true, + expectGetResourceCalled: true, + }, + { + name: "local convert succeeds, so GetResource is not called", + localConvertFails: false, + expectConvertToVersionCalled: true, + expectGetResourceCalled: false, + }, + } + + for _, testCase := range testCases { + testCaseCopy := testCase + t.Run(testCaseCopy.name, func(t *testing.T) { + err := apiextensions.AddToScheme(scheme.Scheme) + require.NoError(t, err) + cluster := newCluster(t, testCRD(), testCronTab()). + WithAPIResources([]kube.APIResourceInfo{ + { + GroupKind: schema.GroupKind{Group: cronTabGroup, Kind: "CronTab"}, + GroupVersionResource: schema.GroupVersionResource{Group: cronTabGroup, Version: "v1", Resource: "crontabs"}, + Meta: metav1.APIResource{Namespaced: true}, + }, + }) + cluster.Invalidate(SetPopulateResourceInfoHandler(func(_ *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + return nil, true + })) + cluster.namespaces = []string{"default"} + + err = cluster.EnsureSynced() + require.NoError(t, err) + + targetDeploy := strToUnstructured(` +apiVersion: stable.example.com/v1 +kind: CronTab +metadata: + name: test-crontab + namespace: default`) + + convertToVersionWasCalled := false + getResourceWasCalled := false + cluster.kubectl.(*kubetest.MockKubectlCmd). + WithConvertToVersionFunc(func(obj *unstructured.Unstructured, _ string, _ string) (*unstructured.Unstructured, error) { + convertToVersionWasCalled = true + + if testCaseCopy.localConvertFails { + return nil, errors.New("failed to convert resource client-side") + } + + return obj, nil + }). + WithGetResourceFunc(func(_ context.Context, _ *rest.Config, _ schema.GroupVersionKind, _ string, _ string) (*unstructured.Unstructured, error) { + getResourceWasCalled = true + return testCronTab(), nil + }) + + managedObjs, err := cluster.GetManagedLiveObjs([]*unstructured.Unstructured{targetDeploy}, func(_ *Resource) bool { + return true + }) + require.NoError(t, err) + assert.Equal(t, testCaseCopy.expectConvertToVersionCalled, convertToVersionWasCalled) + assert.Equal(t, testCaseCopy.expectGetResourceCalled, getResourceWasCalled) + assert.Equal(t, map[kube.ResourceKey]*unstructured.Unstructured{ + kube.NewResourceKey(cronTabGroup, "CronTab", "default", "test-crontab"): mustToUnstructured(testCronTab()), + }, managedObjs) + }) + } +} + +func TestChildDeletedEvent(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + err := cluster.EnsureSynced() + require.NoError(t, err) + + cluster.recordEvent(watch.Deleted, mustToUnstructured(testPod1())) + + rsChildren := getChildren(cluster, mustToUnstructured(testRS())) + assert.Equal(t, []*Resource{}, rsChildren) +} + +func TestProcessNewChildEvent(t *testing.T) { + cluster := newCluster(t, testPod1(), testRS(), testDeploy()) + err := cluster.EnsureSynced() + require.NoError(t, err) + newPod := strToUnstructured(` + apiVersion: v1 + kind: Pod + metadata: + uid: "5" + name: helm-guestbook-pod-1-new + namespace: default + ownerReferences: + - apiVersion: apps/v1 + kind: ReplicaSet + name: helm-guestbook-rs + uid: "2" + resourceVersion: "123"`) + + cluster.recordEvent(watch.Added, newPod) + + rsChildren := getChildren(cluster, mustToUnstructured(testRS())) + sort.Slice(rsChildren, func(i, j int) bool { + return strings.Compare(rsChildren[i].Ref.Name, rsChildren[j].Ref.Name) < 0 + }) + assert.Equal(t, []*Resource{{ + Ref: corev1.ObjectReference{ + Kind: "Pod", + Namespace: "default", + Name: "helm-guestbook-pod-1", + APIVersion: "v1", + UID: "1", + }, + OwnerRefs: []metav1.OwnerReference{{ + APIVersion: "apps/v1", + Kind: "ReplicaSet", + Name: "helm-guestbook-rs", + UID: "2", + }}, + ResourceVersion: "123", + CreationTimestamp: &metav1.Time{ + Time: testCreationTime.Local(), + }, + }, { + Ref: corev1.ObjectReference{ + Kind: "Pod", + Namespace: "default", + Name: "helm-guestbook-pod-1-new", + APIVersion: "v1", + UID: "5", + }, + OwnerRefs: []metav1.OwnerReference{{ + APIVersion: "apps/v1", + Kind: "ReplicaSet", + Name: "helm-guestbook-rs", + UID: "2", + }}, + ResourceVersion: "123", + }}, rsChildren) +} + +func TestWatchCacheUpdated(t *testing.T) { + removed := testPod1() + removed.SetName(removed.GetName() + "-removed-pod") + + updated := testPod1() + updated.SetName(updated.GetName() + "-updated-pod") + updated.SetResourceVersion("updated-pod-version") + + cluster := newCluster(t, removed, updated) + err := cluster.EnsureSynced() + + require.NoError(t, err) + + added := testPod1() + added.SetName(added.GetName() + "-new-pod") + + podGroupKind := testPod1().GroupVersionKind().GroupKind() + + cluster.lock.Lock() + defer cluster.lock.Unlock() + cluster.replaceResourceCache(podGroupKind, []*Resource{cluster.newResource(mustToUnstructured(updated)), cluster.newResource(mustToUnstructured(added))}, "") + + _, ok := cluster.resources[getResourceKey(t, removed)] + assert.False(t, ok) +} + +func TestNamespaceModeReplace(t *testing.T) { + ns1Pod := testPod1() + ns1Pod.SetNamespace("ns1") + ns1Pod.SetName("pod1") + + ns2Pod := testPod1() + ns2Pod.SetNamespace("ns2") + podGroupKind := testPod1().GroupVersionKind().GroupKind() + + cluster := newCluster(t, ns1Pod, ns2Pod) + err := cluster.EnsureSynced() + require.NoError(t, err) + + cluster.lock.Lock() + defer cluster.lock.Unlock() + + cluster.replaceResourceCache(podGroupKind, nil, "ns1") + + _, ok := cluster.resources[getResourceKey(t, ns1Pod)] + assert.False(t, ok) + + _, ok = cluster.resources[getResourceKey(t, ns2Pod)] + assert.True(t, ok) +} + +func TestGetDuplicatedChildren(t *testing.T) { + extensionsRS := testExtensionsRS() + cluster := newCluster(t, testDeploy(), testRS(), extensionsRS) + err := cluster.EnsureSynced() + + require.NoError(t, err) + + // Get children multiple times to make sure the right child is picked up every time. + for i := 0; i < 5; i++ { + children := getChildren(cluster, mustToUnstructured(testDeploy())) + assert.Len(t, children, 1) + assert.Equal(t, "apps/v1", children[0].Ref.APIVersion) + assert.Equal(t, kube.ReplicaSetKind, children[0].Ref.Kind) + assert.Equal(t, testRS().GetName(), children[0].Ref.Name) + } +} + +func TestGetClusterInfo(t *testing.T) { + cluster := newCluster(t) + cluster.apiResources = []kube.APIResourceInfo{{GroupKind: schema.GroupKind{Group: "test", Kind: "test kind"}}} + cluster.serverVersion = "v1.16" + info := cluster.GetClusterInfo() + assert.Equal(t, ClusterInfo{ + Server: cluster.config.Host, + APIResources: cluster.apiResources, + K8SVersion: cluster.serverVersion, + }, info) +} + +func TestDeleteAPIResource(t *testing.T) { + cluster := newCluster(t) + cluster.apiResources = []kube.APIResourceInfo{{ + GroupKind: schema.GroupKind{Group: "test", Kind: "test kind"}, + GroupVersionResource: schema.GroupVersionResource{Version: "v1"}, + }} + + cluster.deleteAPIResource(kube.APIResourceInfo{GroupKind: schema.GroupKind{Group: "wrong group", Kind: "wrong kind"}}) + assert.Len(t, cluster.apiResources, 1) + cluster.deleteAPIResource(kube.APIResourceInfo{ + GroupKind: schema.GroupKind{Group: "test", Kind: "test kind"}, + GroupVersionResource: schema.GroupVersionResource{Version: "wrong version"}, + }) + assert.Len(t, cluster.apiResources, 1) + + cluster.deleteAPIResource(kube.APIResourceInfo{ + GroupKind: schema.GroupKind{Group: "test", Kind: "test kind"}, + GroupVersionResource: schema.GroupVersionResource{Version: "v1"}, + }) + assert.Empty(t, cluster.apiResources) +} + +func TestAppendAPIResource(t *testing.T) { + cluster := newCluster(t) + + resourceInfo := kube.APIResourceInfo{ + GroupKind: schema.GroupKind{Group: "test", Kind: "test kind"}, + GroupVersionResource: schema.GroupVersionResource{Version: "v1"}, + } + + cluster.appendAPIResource(resourceInfo) + assert.ElementsMatch(t, []kube.APIResourceInfo{resourceInfo}, cluster.apiResources) + + // make sure same group, kind version is not added twice + cluster.appendAPIResource(resourceInfo) + assert.ElementsMatch(t, []kube.APIResourceInfo{resourceInfo}, cluster.apiResources) +} + +func ExampleNewClusterCache_resourceUpdatedEvents() { + // kubernetes cluster config here + config := &rest.Config{} + + clusterCache := NewClusterCache(config) + // Ensure cluster is synced before using it + if err := clusterCache.EnsureSynced(); err != nil { + panic(err) + } + unsubscribe := clusterCache.OnResourceUpdated(func(newRes *Resource, oldRes *Resource, _ map[kube.ResourceKey]*Resource) { + switch { + case newRes == nil: + fmt.Printf("%s deleted\n", oldRes.Ref.String()) + case oldRes == nil: + fmt.Printf("%s created\n", newRes.Ref.String()) + default: + fmt.Printf("%s updated\n", newRes.Ref.String()) + } + }) + defer unsubscribe() + // observe resource modifications for 1 minute + time.Sleep(time.Minute) +} + +func getResourceKey(t *testing.T, obj runtime.Object) kube.ResourceKey { + t.Helper() + gvk := obj.GetObjectKind().GroupVersionKind() + m, err := meta.Accessor(obj) + require.NoError(t, err) + return kube.NewResourceKey(gvk.Group, gvk.Kind, m.GetNamespace(), m.GetName()) +} + +func testPod1() *corev1.Pod { + return &corev1.Pod{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "v1", + Kind: "Pod", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook-pod-1", + Namespace: "default", + UID: "1", + ResourceVersion: "123", + CreationTimestamp: metav1.NewTime(testCreationTime), + OwnerReferences: []metav1.OwnerReference{ + { + APIVersion: "apps/v1", + Kind: "ReplicaSet", + Name: "helm-guestbook-rs", + UID: "2", + }, + }, + }, + } +} + +// Similar to pod1, but owner reference lacks uid +func testPod2() *corev1.Pod { + return &corev1.Pod{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "v1", + Kind: "Pod", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook-pod-2", + Namespace: "default", + UID: "4", + ResourceVersion: "123", + CreationTimestamp: metav1.NewTime(testCreationTime), + OwnerReferences: []metav1.OwnerReference{ + { + APIVersion: "apps/v1", + Kind: "ReplicaSet", + Name: "helm-guestbook-rs", + }, + }, + }, + } +} + +func testCRD() *apiextensions.CustomResourceDefinition { + return &apiextensions.CustomResourceDefinition{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apiextensions.k8s.io/v1", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "crontabs.stable.example.com", + }, + Spec: apiextensions.CustomResourceDefinitionSpec{ + Group: "stable.example.com", + Versions: []apiextensions.CustomResourceDefinitionVersion{ + { + Name: "v1", + Served: true, + Storage: true, + Schema: &apiextensions.CustomResourceValidation{ + OpenAPIV3Schema: &apiextensions.JSONSchemaProps{ + Type: "object", + Properties: map[string]apiextensions.JSONSchemaProps{ + "cronSpec": {Type: "string"}, + "image": {Type: "string"}, + "replicas": {Type: "integer"}, + }, + }, + }, + }, + }, + Scope: "Namespaced", + Names: apiextensions.CustomResourceDefinitionNames{ + Plural: "crontabs", + Singular: "crontab", + ShortNames: []string{"ct"}, + Kind: "CronTab", + }, + }, + } +} + +func testCronTab() *unstructured.Unstructured { + return &unstructured.Unstructured{Object: map[string]any{ + "apiVersion": "stable.example.com/v1", + "kind": "CronTab", + "metadata": map[string]any{ + "name": "test-crontab", + "namespace": "default", + }, + "spec": map[string]any{ + "cronSpec": "* * * * */5", + "image": "my-awesome-cron-image", + }, + }} +} + +func testExtensionsRS() *extensionsv1beta1.ReplicaSet { + return &extensionsv1beta1.ReplicaSet{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "extensions/v1beta1", + Kind: "ReplicaSet", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook-rs", + Namespace: "default", + UID: "2", + ResourceVersion: "123", + CreationTimestamp: metav1.NewTime(testCreationTime), + Annotations: map[string]string{ + "deployment.kubernetes.io/revision": "2", + }, + OwnerReferences: []metav1.OwnerReference{ + { + APIVersion: "apps/v1beta1", + Kind: "Deployment", + Name: "helm-guestbook", + UID: "3", + }, + }, + }, + } +} + +func testRS() *appsv1.ReplicaSet { + return &appsv1.ReplicaSet{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "ReplicaSet", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook-rs", + Namespace: "default", + UID: "2", + ResourceVersion: "123", + CreationTimestamp: metav1.NewTime(testCreationTime), + Annotations: map[string]string{ + "deployment.kubernetes.io/revision": "2", + }, + OwnerReferences: []metav1.OwnerReference{ + { + APIVersion: "apps/v1beta1", + Kind: "Deployment", + Name: "helm-guestbook", + UID: "3", + }, + }, + }, + Spec: appsv1.ReplicaSetSpec{}, + Status: appsv1.ReplicaSetStatus{}, + } +} + +func testDeploy() *appsv1.Deployment { + return &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook", + Namespace: "default", + UID: "3", + ResourceVersion: "123", + CreationTimestamp: metav1.NewTime(testCreationTime), + Labels: map[string]string{ + "app.kubernetes.io/instance": "helm-guestbook", + }, + }, + } +} + +func TestIterateHierachyV2(t *testing.T) { + cluster := newCluster(t, testPod1(), testPod2(), testRS(), testExtensionsRS(), testDeploy()) + err := cluster.EnsureSynced() + require.NoError(t, err) + + t.Run("IterateAll", func(t *testing.T) { + startKeys := []kube.ResourceKey{kube.GetResourceKey(mustToUnstructured(testDeploy()))} + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return true + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testPod1())), + kube.GetResourceKey(mustToUnstructured(testPod2())), + kube.GetResourceKey(mustToUnstructured(testRS())), + kube.GetResourceKey(mustToUnstructured(testDeploy())), + }, + keys) + }) + + t.Run("ExitAtRoot", func(t *testing.T) { + startKeys := []kube.ResourceKey{kube.GetResourceKey(mustToUnstructured(testDeploy()))} + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return false + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testDeploy())), + }, + keys) + }) + + t.Run("ExitAtSecondLevelChild", func(t *testing.T) { + startKeys := []kube.ResourceKey{kube.GetResourceKey(mustToUnstructured(testDeploy()))} + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return child.ResourceKey().Kind != kube.ReplicaSetKind + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testDeploy())), + kube.GetResourceKey(mustToUnstructured(testRS())), + }, + keys) + }) + + t.Run("ExitAtThirdLevelChild", func(t *testing.T) { + startKeys := []kube.ResourceKey{kube.GetResourceKey(mustToUnstructured(testDeploy()))} + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return child.ResourceKey().Kind != kube.PodKind + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testDeploy())), + kube.GetResourceKey(mustToUnstructured(testRS())), + kube.GetResourceKey(mustToUnstructured(testPod1())), + kube.GetResourceKey(mustToUnstructured(testPod2())), + }, + keys) + }) + + t.Run("IterateAllStartFromMultiple", func(t *testing.T) { + startKeys := []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testRS())), + kube.GetResourceKey(mustToUnstructured(testDeploy())), + } + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return true + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testPod1())), + kube.GetResourceKey(mustToUnstructured(testPod2())), + kube.GetResourceKey(mustToUnstructured(testRS())), + kube.GetResourceKey(mustToUnstructured(testDeploy())), + }, + keys) + }) + + // After uid is backfilled for owner of pod2, it should appear in results here as well. + t.Run("IterateStartFromExtensionsRS", func(t *testing.T) { + startKeys := []kube.ResourceKey{kube.GetResourceKey(mustToUnstructured(testExtensionsRS()))} + keys := []kube.ResourceKey{} + cluster.IterateHierarchyV2(startKeys, func(child *Resource, _ map[kube.ResourceKey]*Resource) bool { + keys = append(keys, child.ResourceKey()) + return true + }) + + assert.ElementsMatch(t, + []kube.ResourceKey{ + kube.GetResourceKey(mustToUnstructured(testPod1())), + kube.GetResourceKey(mustToUnstructured(testPod2())), + kube.GetResourceKey(mustToUnstructured(testExtensionsRS())), + }, + keys) + }) +} + +// Test_watchEvents_Deadlock validates that starting watches will not create a deadlock +// caused by using improper locking in various callback methods when there is a high load on the +// system. +func Test_watchEvents_Deadlock(t *testing.T) { + // deadlock lock is used to simulate a user function calling the cluster cache while holding a lock + // and using this lock in callbacks such as OnPopulateResourceInfoHandler. + deadlock := sync.RWMutex{} + + hasDeadlock := false + res1 := testPod1() + res2 := testRS() + + cluster := newClusterWithOptions(t, []UpdateSettingsFunc{ + // Set low blocking semaphore + SetListSemaphore(semaphore.NewWeighted(1)), + // Resync watches often to use the semaphore and trigger the rate limiting behavior + SetResyncTimeout(500 * time.Millisecond), + // Use new resource handler to run code in the list callbacks + SetPopulateResourceInfoHandler(func(un *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + if un.GroupVersionKind().GroupKind() == res1.GroupVersionKind().GroupKind() || + un.GroupVersionKind().GroupKind() == res2.GroupVersionKind().GroupKind() { + // Create a bottleneck for resources holding the semaphore + time.Sleep(2 * time.Second) + } + + //// Uncommenting the following code will simulate a different deadlock on purpose caused by + //// client code holding a lock and trying to acquire the same lock in the event callback. + //// It provides an easy way to validate if the test detect deadlocks as expected. + //// If the test fails with this code commented, a deadlock do exist in the codebase. + // deadlock.RLock() + // defer deadlock.RUnlock() + + return + }), + }, res1, res2, testDeploy()) + defer func() { + // Invalidate() is a blocking method and cannot be called safely in case of deadlock + if !hasDeadlock { + cluster.Invalidate() + } + }() + + err := cluster.EnsureSynced() + require.NoError(t, err) + + for i := 0; i < 2; i++ { + done := make(chan bool, 1) + go func() { + // Stop the watches, so startMissingWatches will restart them + cluster.stopWatching(res1.GroupVersionKind().GroupKind(), res1.Namespace) + cluster.stopWatching(res2.GroupVersionKind().GroupKind(), res2.Namespace) + + // calling startMissingWatches to simulate that a CRD event was received + // TODO: how to simulate real watch events and test the full watchEvents function? + err = runSynced(&cluster.lock, func() error { + deadlock.Lock() + defer deadlock.Unlock() + return cluster.startMissingWatches() + }) + require.NoError(t, err) + done <- true + }() + select { + case v := <-done: + require.True(t, v) + case <-time.After(10 * time.Second): + hasDeadlock = true + t.Errorf("timeout reached on attempt %d. It is possible that a deadlock occurred", i) + // Tip: to debug the deadlock, increase the timer to a value higher than X in "go test -timeout X" + // This will make the test panic with the goroutines information + t.FailNow() + } + } +} + +func buildTestResourceMap() map[kube.ResourceKey]*Resource { + ns := make(map[kube.ResourceKey]*Resource) + for i := 0; i < 100000; i++ { + name := fmt.Sprintf("test-%d", i) + ownerName := fmt.Sprintf("test-%d", i/10) + uid := uuid.New().String() + key := kube.ResourceKey{ + Namespace: "default", + Name: name, + Kind: "Pod", + } + resourceYaml := fmt.Sprintf(` +apiVersion: v1 +kind: Pod +metadata: + namespace: default + name: %s + uid: %s`, name, uid) + if i/10 != 0 { + owner := ns[kube.ResourceKey{ + Namespace: "default", + Name: ownerName, + Kind: "Pod", + }] + ownerUid := owner.Ref.UID + resourceYaml += fmt.Sprintf(` + ownerReferences: + - apiVersion: v1 + kind: Pod + name: %s + uid: %s`, ownerName, ownerUid) + } + ns[key] = cacheTest.newResource(strToUnstructured(resourceYaml)) + } + return ns +} + +func BenchmarkBuildGraph(b *testing.B) { + testResources := buildTestResourceMap() + b.ResetTimer() + for n := 0; n < b.N; n++ { + buildGraph(testResources) + } +} + +func BenchmarkIterateHierarchyV2(b *testing.B) { + cluster := newCluster(b) + testResources := buildTestResourceMap() + for _, resource := range testResources { + cluster.setNode(resource) + } + b.ResetTimer() + for n := 0; n < b.N; n++ { + cluster.IterateHierarchyV2([]kube.ResourceKey{ + {Namespace: "default", Name: "test-1", Kind: "Pod"}, + }, func(_ *Resource, _ map[kube.ResourceKey]*Resource) bool { + return true + }) + } +} diff --git a/gitops-engine/pkg/cache/doc.go b/gitops-engine/pkg/cache/doc.go new file mode 100644 index 0000000000000..b45bd352c122d --- /dev/null +++ b/gitops-engine/pkg/cache/doc.go @@ -0,0 +1,9 @@ +/* +Package cache implements lightweight Kubernetes cluster caching that stores only resource references and ownership +references. In addition to references cache might be configured to store custom metadata and whole body of selected +resources. + +The library uses Kubernetes watch API to maintain cache up to date. This approach reduces number of Kubernetes +API requests and provides instant access to the required Kubernetes resources. +*/ +package cache diff --git a/gitops-engine/pkg/cache/mocks/ClusterCache.go b/gitops-engine/pkg/cache/mocks/ClusterCache.go new file mode 100644 index 0000000000000..b0179f85aba40 --- /dev/null +++ b/gitops-engine/pkg/cache/mocks/ClusterCache.go @@ -0,0 +1,312 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +package mocks + +import ( + cache "github.com/argoproj/gitops-engine/pkg/cache" + kube "github.com/argoproj/gitops-engine/pkg/utils/kube" + + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + + mock "github.com/stretchr/testify/mock" + + openapi "k8s.io/kubectl/pkg/util/openapi" + + schema "k8s.io/apimachinery/pkg/runtime/schema" + + unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +// ClusterCache is an autogenerated mock type for the ClusterCache type +type ClusterCache struct { + mock.Mock +} + +// EnsureSynced provides a mock function with given fields: +func (_m *ClusterCache) EnsureSynced() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for EnsureSynced") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// FindResources provides a mock function with given fields: namespace, predicates +func (_m *ClusterCache) FindResources(namespace string, predicates ...func(*cache.Resource) bool) map[kube.ResourceKey]*cache.Resource { + _va := make([]interface{}, len(predicates)) + for _i := range predicates { + _va[_i] = predicates[_i] + } + var _ca []interface{} + _ca = append(_ca, namespace) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FindResources") + } + + var r0 map[kube.ResourceKey]*cache.Resource + if rf, ok := ret.Get(0).(func(string, ...func(*cache.Resource) bool) map[kube.ResourceKey]*cache.Resource); ok { + r0 = rf(namespace, predicates...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[kube.ResourceKey]*cache.Resource) + } + } + + return r0 +} + +// GetAPIResources provides a mock function with given fields: +func (_m *ClusterCache) GetAPIResources() []kube.APIResourceInfo { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAPIResources") + } + + var r0 []kube.APIResourceInfo + if rf, ok := ret.Get(0).(func() []kube.APIResourceInfo); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]kube.APIResourceInfo) + } + } + + return r0 +} + +// GetClusterInfo provides a mock function with given fields: +func (_m *ClusterCache) GetClusterInfo() cache.ClusterInfo { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetClusterInfo") + } + + var r0 cache.ClusterInfo + if rf, ok := ret.Get(0).(func() cache.ClusterInfo); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(cache.ClusterInfo) + } + + return r0 +} + +// GetGVKParser provides a mock function with given fields: +func (_m *ClusterCache) GetGVKParser() *managedfields.GvkParser { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetGVKParser") + } + + var r0 *managedfields.GvkParser + if rf, ok := ret.Get(0).(func() *managedfields.GvkParser); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*managedfields.GvkParser) + } + } + + return r0 +} + +// GetManagedLiveObjs provides a mock function with given fields: targetObjs, isManaged +func (_m *ClusterCache) GetManagedLiveObjs(targetObjs []*unstructured.Unstructured, isManaged func(*cache.Resource) bool) (map[kube.ResourceKey]*unstructured.Unstructured, error) { + ret := _m.Called(targetObjs, isManaged) + + if len(ret) == 0 { + panic("no return value specified for GetManagedLiveObjs") + } + + var r0 map[kube.ResourceKey]*unstructured.Unstructured + var r1 error + if rf, ok := ret.Get(0).(func([]*unstructured.Unstructured, func(*cache.Resource) bool) (map[kube.ResourceKey]*unstructured.Unstructured, error)); ok { + return rf(targetObjs, isManaged) + } + if rf, ok := ret.Get(0).(func([]*unstructured.Unstructured, func(*cache.Resource) bool) map[kube.ResourceKey]*unstructured.Unstructured); ok { + r0 = rf(targetObjs, isManaged) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[kube.ResourceKey]*unstructured.Unstructured) + } + } + + if rf, ok := ret.Get(1).(func([]*unstructured.Unstructured, func(*cache.Resource) bool) error); ok { + r1 = rf(targetObjs, isManaged) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetOpenAPISchema provides a mock function with given fields: +func (_m *ClusterCache) GetOpenAPISchema() openapi.Resources { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetOpenAPISchema") + } + + var r0 openapi.Resources + if rf, ok := ret.Get(0).(func() openapi.Resources); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(openapi.Resources) + } + } + + return r0 +} + +// GetServerVersion provides a mock function with given fields: +func (_m *ClusterCache) GetServerVersion() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetServerVersion") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Invalidate provides a mock function with given fields: opts +func (_m *ClusterCache) Invalidate(opts ...cache.UpdateSettingsFunc) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + _m.Called(_ca...) +} + +// IsNamespaced provides a mock function with given fields: gk +func (_m *ClusterCache) IsNamespaced(gk schema.GroupKind) (bool, error) { + ret := _m.Called(gk) + + if len(ret) == 0 { + panic("no return value specified for IsNamespaced") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(schema.GroupKind) (bool, error)); ok { + return rf(gk) + } + if rf, ok := ret.Get(0).(func(schema.GroupKind) bool); ok { + r0 = rf(gk) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(schema.GroupKind) error); ok { + r1 = rf(gk) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IterateHierarchyV2 provides a mock function with given fields: keys, action +func (_m *ClusterCache) IterateHierarchyV2(keys []kube.ResourceKey, action func(*cache.Resource, map[kube.ResourceKey]*cache.Resource) bool) { + _m.Called(keys, action) +} + +// OnEvent provides a mock function with given fields: handler +func (_m *ClusterCache) OnEvent(handler cache.OnEventHandler) cache.Unsubscribe { + ret := _m.Called(handler) + + if len(ret) == 0 { + panic("no return value specified for OnEvent") + } + + var r0 cache.Unsubscribe + if rf, ok := ret.Get(0).(func(cache.OnEventHandler) cache.Unsubscribe); ok { + r0 = rf(handler) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Unsubscribe) + } + } + + return r0 +} + +// OnProcessEventsHandler provides a mock function with given fields: handler +func (_m *ClusterCache) OnProcessEventsHandler(handler cache.OnProcessEventsHandler) cache.Unsubscribe { + ret := _m.Called(handler) + + if len(ret) == 0 { + panic("no return value specified for OnProcessEventsHandler") + } + + var r0 cache.Unsubscribe + if rf, ok := ret.Get(0).(func(cache.OnProcessEventsHandler) cache.Unsubscribe); ok { + r0 = rf(handler) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Unsubscribe) + } + } + + return r0 +} + +// OnResourceUpdated provides a mock function with given fields: handler +func (_m *ClusterCache) OnResourceUpdated(handler cache.OnResourceUpdatedHandler) cache.Unsubscribe { + ret := _m.Called(handler) + + if len(ret) == 0 { + panic("no return value specified for OnResourceUpdated") + } + + var r0 cache.Unsubscribe + if rf, ok := ret.Get(0).(func(cache.OnResourceUpdatedHandler) cache.Unsubscribe); ok { + r0 = rf(handler) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cache.Unsubscribe) + } + } + + return r0 +} + +// NewClusterCache creates a new instance of ClusterCache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClusterCache(t interface { + mock.TestingT + Cleanup(func()) +}) *ClusterCache { + mock := &ClusterCache{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gitops-engine/pkg/cache/predicates.go b/gitops-engine/pkg/cache/predicates.go new file mode 100644 index 0000000000000..53c05529d7387 --- /dev/null +++ b/gitops-engine/pkg/cache/predicates.go @@ -0,0 +1,14 @@ +package cache + +// TopLevelResource returns true if resource has no parents +func TopLevelResource(r *Resource) bool { + return len(r.OwnerRefs) == 0 +} + +// ResourceOfGroupKind returns predicate that matches resource by specified group and kind +func ResourceOfGroupKind(group string, kind string) func(r *Resource) bool { + return func(r *Resource) bool { + key := r.ResourceKey() + return key.Group == group && key.Kind == kind + } +} diff --git a/gitops-engine/pkg/cache/predicates_test.go b/gitops-engine/pkg/cache/predicates_test.go new file mode 100644 index 0000000000000..74522f71e79ed --- /dev/null +++ b/gitops-engine/pkg/cache/predicates_test.go @@ -0,0 +1,123 @@ +package cache + +import ( + "fmt" + "testing" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/rest" +) + +func TestResourceOfGroupKind(t *testing.T) { + deploy := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "deploy", + }, + } + service := &corev1.Service{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "", + Kind: "Service", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "service", + }, + } + + cluster := newCluster(t, deploy, service) + err := cluster.EnsureSynced() + require.NoError(t, err) + + resources := cluster.FindResources("", ResourceOfGroupKind("apps", "Deployment")) + assert.Len(t, resources, 1) + assert.NotNil(t, resources[kube.NewResourceKey("apps", "Deployment", "", "deploy")]) +} + +func TestGetNamespaceResources(t *testing.T) { + defaultNamespaceTopLevel1 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook1", + Namespace: "default", + }, + } + defaultNamespaceTopLevel2 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook2", + Namespace: "default", + }, + } + kubesystemNamespaceTopLevel2 := &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "helm-guestbook3", + Namespace: "kube-system", + }, + } + + cluster := newCluster(t, defaultNamespaceTopLevel1, defaultNamespaceTopLevel2, kubesystemNamespaceTopLevel2) + err := cluster.EnsureSynced() + require.NoError(t, err) + + resources := cluster.FindResources("default", TopLevelResource) + assert.Len(t, resources, 2) + assert.Equal(t, "helm-guestbook1", resources[getResourceKey(t, defaultNamespaceTopLevel1)].Ref.Name) + assert.Equal(t, "helm-guestbook2", resources[getResourceKey(t, defaultNamespaceTopLevel2)].Ref.Name) + + resources = cluster.FindResources("kube-system", TopLevelResource) + assert.Len(t, resources, 1) + assert.Equal(t, "helm-guestbook3", resources[getResourceKey(t, kubesystemNamespaceTopLevel2)].Ref.Name) +} + +func ExampleNewClusterCache_inspectNamespaceResources() { + // kubernetes cluster config here + config := &rest.Config{} + + clusterCache := NewClusterCache(config, + // cache default namespace only + SetNamespaces([]string{"default", "kube-system"}), + // configure custom logic to cache resources manifest and additional metadata + SetPopulateResourceInfoHandler(func(un *unstructured.Unstructured, _ bool) (info any, cacheManifest bool) { + // if resource belongs to 'extensions' group then mark if with 'deprecated' label + if un.GroupVersionKind().Group == "extensions" { + info = []string{"deprecated"} + } + _, ok := un.GetLabels()["acme.io/my-label"] + // cache whole manifest if resource has label + cacheManifest = ok + return + }), + ) + // Ensure cluster is synced before using it + if err := clusterCache.EnsureSynced(); err != nil { + panic(err) + } + // Iterate default namespace resources tree + for _, root := range clusterCache.FindResources("default", TopLevelResource) { + clusterCache.IterateHierarchyV2([]kube.ResourceKey{root.ResourceKey()}, func(resource *Resource, _ map[kube.ResourceKey]*Resource) bool { + fmt.Printf("resource: %s, info: %v\n", resource.Ref.String(), resource.Info) + return true + }) + } +} diff --git a/gitops-engine/pkg/cache/references.go b/gitops-engine/pkg/cache/references.go new file mode 100644 index 0000000000000..cb16314b9d580 --- /dev/null +++ b/gitops-engine/pkg/cache/references.go @@ -0,0 +1,108 @@ +package cache + +import ( + "encoding/json" + "fmt" + "regexp" + + appsv1 "k8s.io/api/apps/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/types" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +// mightHaveInferredOwner returns true of given resource might have inferred owners +func mightHaveInferredOwner(r *Resource) bool { + return r.Ref.GroupVersionKind().Group == "" && r.Ref.Kind == kube.PersistentVolumeClaimKind +} + +func (c *clusterCache) resolveResourceReferences(un *unstructured.Unstructured) ([]metav1.OwnerReference, func(kube.ResourceKey) bool) { + var isInferredParentOf func(_ kube.ResourceKey) bool + ownerRefs := un.GetOwnerReferences() + gvk := un.GroupVersionKind() + + switch { + // Special case for endpoint. Remove after https://github.com/kubernetes/kubernetes/issues/28483 is fixed + case gvk.Group == "" && gvk.Kind == kube.EndpointsKind && len(ownerRefs) == 0: + ownerRefs = append(ownerRefs, metav1.OwnerReference{ + Name: un.GetName(), + Kind: kube.ServiceKind, + APIVersion: "v1", + }) + + // Special case for Operator Lifecycle Manager ClusterServiceVersion: + case gvk.Group == "operators.coreos.com" && gvk.Kind == "ClusterServiceVersion": + if un.GetAnnotations()["olm.operatorGroup"] != "" { + ownerRefs = append(ownerRefs, metav1.OwnerReference{ + Name: un.GetAnnotations()["olm.operatorGroup"], + Kind: "OperatorGroup", + APIVersion: "operators.coreos.com/v1", + }) + } + + // Edge case: consider auto-created service account tokens as a child of service account objects + case gvk.Kind == kube.SecretKind && gvk.Group == "": + if yes, ref := isServiceAccountTokenSecret(un); yes { + ownerRefs = append(ownerRefs, ref) + } + + case (gvk.Group == "apps" || gvk.Group == "extensions") && gvk.Kind == kube.StatefulSetKind: + if refs, err := isStatefulSetChild(un); err != nil { + c.log.Error(err, fmt.Sprintf("Failed to extract StatefulSet %s/%s PVC references", un.GetNamespace(), un.GetName())) + } else { + isInferredParentOf = refs + } + } + + return ownerRefs, isInferredParentOf +} + +func isStatefulSetChild(un *unstructured.Unstructured) (func(kube.ResourceKey) bool, error) { + sts := appsv1.StatefulSet{} + data, err := json.Marshal(un) + if err != nil { + return nil, fmt.Errorf("failed to marshal unstructured object: %w", err) + } + err = json.Unmarshal(data, &sts) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal statefulset: %w", err) + } + + templates := sts.Spec.VolumeClaimTemplates + return func(key kube.ResourceKey) bool { + if key.Kind == kube.PersistentVolumeClaimKind && key.GroupKind().Group == "" { + for _, templ := range templates { + if match, _ := regexp.MatchString(fmt.Sprintf(`%s-%s-\d+$`, templ.Name, un.GetName()), key.Name); match { + return true + } + } + } + return false + }, nil +} + +func isServiceAccountTokenSecret(un *unstructured.Unstructured) (bool, metav1.OwnerReference) { + ref := metav1.OwnerReference{ + APIVersion: "v1", + Kind: kube.ServiceAccountKind, + } + + if typeVal, ok, err := unstructured.NestedString(un.Object, "type"); !ok || err != nil || typeVal != "kubernetes.io/service-account-token" { + return false, ref + } + + annotations := un.GetAnnotations() + if annotations == nil { + return false, ref + } + + id, okId := annotations["kubernetes.io/service-account.uid"] + name, okName := annotations["kubernetes.io/service-account.name"] + if okId && okName { + ref.Name = name + ref.UID = types.UID(id) + } + return ref.Name != "" && ref.UID != "", ref +} diff --git a/gitops-engine/pkg/cache/references_test.go b/gitops-engine/pkg/cache/references_test.go new file mode 100644 index 0000000000000..bc496fa61d14f --- /dev/null +++ b/gitops-engine/pkg/cache/references_test.go @@ -0,0 +1,106 @@ +package cache + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func Test_isStatefulSetChild(t *testing.T) { + type args struct { + un *unstructured.Unstructured + } + + statefulSet := &appsv1.StatefulSet{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1", + Kind: "StatefulSet", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "sw-broker", + }, + Spec: appsv1.StatefulSetSpec{ + VolumeClaimTemplates: []corev1.PersistentVolumeClaim{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "emqx-data", + }, + }, + }, + }, + } + + // Create a new unstructured object from the JSON string + un, err := kube.ToUnstructured(statefulSet) + require.NoErrorf(t, err, "Failed to convert StatefulSet to unstructured: %v", err) + + tests := []struct { + name string + args args + wantErr bool + checkFunc func(func(kube.ResourceKey) bool) bool + }{ + { + name: "Valid PVC for sw-broker", + args: args{un: un}, + wantErr: false, + checkFunc: func(fn func(kube.ResourceKey) bool) bool { + // Check a valid PVC name for "sw-broker" + return fn(kube.ResourceKey{Kind: "PersistentVolumeClaim", Name: "emqx-data-sw-broker-0"}) + }, + }, + { + name: "Invalid PVC for sw-broker", + args: args{un: un}, + wantErr: false, + checkFunc: func(fn func(kube.ResourceKey) bool) bool { + // Check an invalid PVC name that should belong to "sw-broker-internal" + return !fn(kube.ResourceKey{Kind: "PersistentVolumeClaim", Name: "emqx-data-sw-broker-internal-0"}) + }, + }, + { + name: "Mismatch PVC for sw-broker", + args: args{un: &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "apps/v1", + "kind": "StatefulSet", + "metadata": map[string]any{ + "name": "sw-broker", + }, + "spec": map[string]any{ + "volumeClaimTemplates": []any{ + map[string]any{ + "metadata": map[string]any{ + "name": "volume-2", + }, + }, + }, + }, + }, + }}, + wantErr: false, + checkFunc: func(fn func(kube.ResourceKey) bool) bool { + // Check an invalid PVC name for "api-test" + return !fn(kube.ResourceKey{Kind: "PersistentVolumeClaim", Name: "volume-2"}) + }, + }, + } + + // Execute test cases + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := isStatefulSetChild(tt.args.un) + assert.Equal(t, tt.wantErr, err != nil, "isStatefulSetChild() error = %v, wantErr %v", err, tt.wantErr) + if err == nil { + assert.True(t, tt.checkFunc(got), "Check function failed for %v", tt.name) + } + }) + } +} diff --git a/gitops-engine/pkg/cache/resource.go b/gitops-engine/pkg/cache/resource.go new file mode 100644 index 0000000000000..8a7202950ee88 --- /dev/null +++ b/gitops-engine/pkg/cache/resource.go @@ -0,0 +1,107 @@ +package cache + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/types" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +// Resource holds the information about Kubernetes resource, ownership references and optional information +type Resource struct { + // ResourceVersion holds most recent observed resource version + ResourceVersion string + // Resource reference + Ref corev1.ObjectReference + // References to resource owners + OwnerRefs []metav1.OwnerReference + // Optional creation timestamp of the resource + CreationTimestamp *metav1.Time + // Optional additional information about the resource + Info any + // Optional whole resource manifest + Resource *unstructured.Unstructured + + // answers if resource is inferred parent of provided resource + isInferredParentOf func(key kube.ResourceKey) bool +} + +func (r *Resource) ResourceKey() kube.ResourceKey { + return kube.NewResourceKey(r.Ref.GroupVersionKind().Group, r.Ref.Kind, r.Ref.Namespace, r.Ref.Name) +} + +func (r *Resource) isParentOf(child *Resource) bool { + for i, ownerRef := range child.OwnerRefs { + // backfill UID of inferred owner child references + if ownerRef.UID == "" && r.Ref.Kind == ownerRef.Kind && r.Ref.APIVersion == ownerRef.APIVersion && r.Ref.Name == ownerRef.Name { + ownerRef.UID = r.Ref.UID + child.OwnerRefs[i] = ownerRef + return true + } + + if r.Ref.UID == ownerRef.UID { + return true + } + } + + return false +} + +// setOwnerRef adds or removes specified owner reference +func (r *Resource) setOwnerRef(ref metav1.OwnerReference, add bool) { + index := -1 + for i, item := range r.OwnerRefs { + if item.UID == ref.UID { + index = i + break + } + } + added := index > -1 + if add != added { + if add { + r.OwnerRefs = append(r.OwnerRefs, ref) + } else { + r.OwnerRefs = append(r.OwnerRefs[:index], r.OwnerRefs[index+1:]...) + } + } +} + +func (r *Resource) toOwnerRef() metav1.OwnerReference { + return metav1.OwnerReference{UID: r.Ref.UID, Name: r.Ref.Name, Kind: r.Ref.Kind, APIVersion: r.Ref.APIVersion} +} + +// iterateChildrenV2 is a depth-first traversal of the graph of resources starting from the current resource. +func (r *Resource) iterateChildrenV2(graph map[kube.ResourceKey]map[types.UID]*Resource, ns map[kube.ResourceKey]*Resource, visited map[kube.ResourceKey]int, action func(err error, child *Resource, namespaceResources map[kube.ResourceKey]*Resource) bool) { + key := r.ResourceKey() + if visited[key] == 2 { + return + } + // this indicates that we've started processing this node's children + visited[key] = 1 + defer func() { + // this indicates that we've finished processing this node's children + visited[key] = 2 + }() + children, ok := graph[key] + if !ok || children == nil { + return + } + for _, c := range children { + childKey := c.ResourceKey() + child := ns[childKey] + switch visited[childKey] { + case 1: + // Since we encountered a node that we're currently processing, we know we have a circular dependency. + _ = action(fmt.Errorf("circular dependency detected. %s is child and parent of %s", childKey.String(), key.String()), child, ns) + case 0: + if action(nil, child, ns) { + child.iterateChildrenV2(graph, ns, visited, action) + } + } + } +} diff --git a/gitops-engine/pkg/cache/resource_test.go b/gitops-engine/pkg/cache/resource_test.go new file mode 100644 index 0000000000000..a3b06a6cc7157 --- /dev/null +++ b/gitops-engine/pkg/cache/resource_test.go @@ -0,0 +1,80 @@ +package cache + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/client-go/rest" +) + +var cacheTest = NewClusterCache(&rest.Config{}) + +func TestIsParentOf(t *testing.T) { + child := cacheTest.newResource(mustToUnstructured(testPod1())) + parent := cacheTest.newResource(mustToUnstructured(testRS())) + grandParent := cacheTest.newResource(mustToUnstructured(testDeploy())) + + assert.True(t, parent.isParentOf(child)) + assert.False(t, grandParent.isParentOf(child)) +} + +func TestIsParentOfSameKindDifferentGroupAndUID(t *testing.T) { + rs := testRS() + rs.APIVersion = "somecrd.io/v1" + rs.SetUID("123") + child := cacheTest.newResource(mustToUnstructured(testPod1())) + invalidParent := cacheTest.newResource(mustToUnstructured(rs)) + + assert.False(t, invalidParent.isParentOf(child)) +} + +func TestIsServiceParentOfEndPointWithTheSameName(t *testing.T) { + nonMatchingNameEndPoint := cacheTest.newResource(strToUnstructured(` +apiVersion: v1 +kind: Endpoints +metadata: + name: not-matching-name + namespace: default +`)) + + matchingNameEndPoint := cacheTest.newResource(strToUnstructured(` +apiVersion: v1 +kind: Endpoints +metadata: + name: helm-guestbook + namespace: default +`)) + + parent := cacheTest.newResource(testService) + + assert.True(t, parent.isParentOf(matchingNameEndPoint)) + assert.Equal(t, parent.Ref.UID, matchingNameEndPoint.OwnerRefs[0].UID) + assert.False(t, parent.isParentOf(nonMatchingNameEndPoint)) +} + +func TestIsServiceAccountParentOfSecret(t *testing.T) { + serviceAccount := cacheTest.newResource(strToUnstructured(` +apiVersion: v1 +kind: ServiceAccount +metadata: + name: default + namespace: default + uid: '123' +secrets: +- name: default-token-123 +`)) + tokenSecret := cacheTest.newResource(strToUnstructured(` +apiVersion: v1 +kind: Secret +metadata: + annotations: + kubernetes.io/service-account.name: default + kubernetes.io/service-account.uid: '123' + name: default-token-123 + namespace: default + uid: '345' +type: kubernetes.io/service-account-token +`)) + + assert.True(t, serviceAccount.isParentOf(tokenSecret)) +} diff --git a/gitops-engine/pkg/cache/settings.go b/gitops-engine/pkg/cache/settings.go new file mode 100644 index 0000000000000..692ac26748353 --- /dev/null +++ b/gitops-engine/pkg/cache/settings.go @@ -0,0 +1,185 @@ +package cache + +import ( + "time" + + "github.com/go-logr/logr" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/rest" + + "github.com/argoproj/gitops-engine/pkg/health" + "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +// NewNoopSettings returns cache settings that has not health customizations and don't filter any resources +func NewNoopSettings() *noopSettings { + return &noopSettings{} +} + +type noopSettings struct{} + +func (f *noopSettings) GetResourceHealth(_ *unstructured.Unstructured) (*health.HealthStatus, error) { + return nil, nil +} + +func (f *noopSettings) IsExcludedResource(_, _, _ string) bool { + return false +} + +// Settings caching customizations +type Settings struct { + // ResourceHealthOverride contains health assessment overrides + ResourceHealthOverride health.HealthOverride + // ResourcesFilter holds filter that excludes resources + ResourcesFilter kube.ResourceFilter +} + +type UpdateSettingsFunc func(cache *clusterCache) + +// SetKubectl allows to override kubectl wrapper implementation +func SetKubectl(kubectl kube.Kubectl) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.kubectl = kubectl + } +} + +// SetPopulateResourceInfoHandler updates handler that populates resource info +func SetPopulateResourceInfoHandler(handler OnPopulateResourceInfoHandler) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.populateResourceInfoHandler = handler + } +} + +// SetSettings updates caching settings +func SetSettings(settings Settings) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.settings = Settings{settings.ResourceHealthOverride, settings.ResourcesFilter} + } +} + +// SetNamespaces updates list of monitored namespaces +func SetNamespaces(namespaces []string) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.namespaces = namespaces + } +} + +// SetClusterResources specifies if cluster level resource included or not. +// Flag is used only if cluster is changed to namespaced mode using SetNamespaces setting +func SetClusterResources(val bool) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.clusterResources = val + } +} + +// SetConfig updates cluster rest config +func SetConfig(config *rest.Config) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.config = config + } +} + +// SetListPageSize sets the page size for list pager. +func SetListPageSize(listPageSize int64) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.listPageSize = listPageSize + } +} + +// SetListPageBufferSize sets the number of pages to prefetch for list pager. +func SetListPageBufferSize(listPageBufferSize int32) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.listPageBufferSize = listPageBufferSize + } +} + +// SetListSemaphore sets the semaphore for list operations. +// Taking an object rather than a number allows to share a semaphore among multiple caches if necessary. +func SetListSemaphore(listSemaphore WeightedSemaphore) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.listSemaphore = listSemaphore + } +} + +// SetResyncTimeout updates cluster re-sync timeout +func SetResyncTimeout(timeout time.Duration) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.syncStatus.lock.Lock() + defer cache.syncStatus.lock.Unlock() + + cache.syncStatus.resyncTimeout = timeout + } +} + +// SetWatchResyncTimeout updates cluster re-sync timeout +func SetWatchResyncTimeout(timeout time.Duration) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.watchResyncTimeout = timeout + } +} + +// SetClusterSyncRetryTimeout updates cluster sync retry timeout when sync error happens +func SetClusterSyncRetryTimeout(timeout time.Duration) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.clusterSyncRetryTimeout = timeout + } +} + +// SetLogr sets the logger to use. +func SetLogr(log logr.Logger) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.log = log + if kcmd, ok := cache.kubectl.(*kube.KubectlCmd); ok { + kcmd.Log = log + } + } +} + +// SetTracer sets the tracer to use. +func SetTracer(tracer tracing.Tracer) UpdateSettingsFunc { + return func(cache *clusterCache) { + if kcmd, ok := cache.kubectl.(*kube.KubectlCmd); ok { + kcmd.Tracer = tracer + } + } +} + +// SetRetryOptions sets cluster list retry options +func SetRetryOptions(maxRetries int32, useBackoff bool, retryFunc ListRetryFunc) UpdateSettingsFunc { + return func(cache *clusterCache) { + // Max retries must be at least one + if maxRetries < 1 { + maxRetries = 1 + } + cache.listRetryLimit = maxRetries + cache.listRetryUseBackoff = useBackoff + cache.listRetryFunc = retryFunc + } +} + +// SetRespectRBAC allows to set whether to respect the controller rbac in list/watches +func SetRespectRBAC(respectRBAC int) UpdateSettingsFunc { + return func(cache *clusterCache) { + // if invalid value is provided disable respect rbac + if respectRBAC < RespectRbacDisabled || respectRBAC > RespectRbacStrict { + cache.respectRBAC = RespectRbacDisabled + } else { + cache.respectRBAC = respectRBAC + } + } +} + +// SetBatchEventsProcessing allows to set whether to process events in batch +func SetBatchEventsProcessing(batchProcessing bool) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.batchEventsProcessing = batchProcessing + } +} + +// SetEventProcessingInterval allows to set the interval for processing events +func SetEventProcessingInterval(interval time.Duration) UpdateSettingsFunc { + return func(cache *clusterCache) { + cache.eventProcessingInterval = interval + } +} diff --git a/gitops-engine/pkg/cache/settings_test.go b/gitops-engine/pkg/cache/settings_test.go new file mode 100644 index 0000000000000..fdc1a7412899a --- /dev/null +++ b/gitops-engine/pkg/cache/settings_test.go @@ -0,0 +1,74 @@ +package cache + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + "k8s.io/client-go/rest" + + "github.com/argoproj/gitops-engine/pkg/utils/kube/kubetest" +) + +func TestSetSettings(t *testing.T) { + cache := NewClusterCache(&rest.Config{}, SetKubectl(&kubetest.MockKubectlCmd{})) + updatedHealth := &noopSettings{} + updatedFilter := &noopSettings{} + cache.Invalidate(SetSettings(Settings{ResourceHealthOverride: updatedHealth, ResourcesFilter: updatedFilter})) + + assert.Equal(t, updatedFilter, cache.settings.ResourcesFilter) + assert.Equal(t, updatedHealth, cache.settings.ResourceHealthOverride) +} + +func TestSetConfig(t *testing.T) { + cache := NewClusterCache(&rest.Config{}, SetKubectl(&kubetest.MockKubectlCmd{})) + updatedConfig := &rest.Config{Host: "http://newhost"} + cache.Invalidate(SetConfig(updatedConfig)) + + assert.Equal(t, updatedConfig, cache.config) +} + +func TestSetNamespaces(t *testing.T) { + cache := NewClusterCache(&rest.Config{}, SetKubectl(&kubetest.MockKubectlCmd{}), SetNamespaces([]string{"default"})) + + updatedNamespaces := []string{"updated"} + cache.Invalidate(SetNamespaces(updatedNamespaces)) + + assert.ElementsMatch(t, updatedNamespaces, cache.namespaces) +} + +func TestSetResyncTimeout(t *testing.T) { + cache := NewClusterCache(&rest.Config{}) + assert.Equal(t, defaultClusterResyncTimeout, cache.syncStatus.resyncTimeout) + + timeout := 1 * time.Hour + cache.Invalidate(SetResyncTimeout(timeout)) + + assert.Equal(t, timeout, cache.syncStatus.resyncTimeout) +} + +func TestSetWatchResyncTimeout(t *testing.T) { + cache := NewClusterCache(&rest.Config{}) + assert.Equal(t, defaultWatchResyncTimeout, cache.watchResyncTimeout) + + timeout := 30 * time.Minute + cache = NewClusterCache(&rest.Config{}, SetWatchResyncTimeout(timeout)) + assert.Equal(t, timeout, cache.watchResyncTimeout) +} + +func TestSetBatchEventsProcessing(t *testing.T) { + cache := NewClusterCache(&rest.Config{}) + assert.False(t, cache.batchEventsProcessing) + + cache.Invalidate(SetBatchEventsProcessing(true)) + assert.True(t, cache.batchEventsProcessing) +} + +func TestSetEventsProcessingInterval(t *testing.T) { + cache := NewClusterCache(&rest.Config{}) + assert.Equal(t, defaultEventProcessingInterval, cache.eventProcessingInterval) + + interval := 1 * time.Second + cache.Invalidate(SetEventProcessingInterval(interval)) + assert.Equal(t, interval, cache.eventProcessingInterval) +} diff --git a/gitops-engine/pkg/diff/diff.go b/gitops-engine/pkg/diff/diff.go new file mode 100644 index 0000000000000..166ec2fd683d8 --- /dev/null +++ b/gitops-engine/pkg/diff/diff.go @@ -0,0 +1,1176 @@ +/* +The package provide functions that allows to compare set of Kubernetes resources using the logic equivalent to +`kubectl diff`. +*/ +package diff + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "reflect" + + jsonpatch "github.com/evanphx/json-patch/v5" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/jsonmergepatch" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/apimachinery/pkg/util/strategicpatch" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/structured-merge-diff/v6/fieldpath" + "sigs.k8s.io/structured-merge-diff/v6/merge" + "sigs.k8s.io/structured-merge-diff/v6/typed" + + "github.com/argoproj/gitops-engine/internal/kubernetes_vendor/pkg/api/v1/endpoints" + "github.com/argoproj/gitops-engine/pkg/diff/internal/fieldmanager" + "github.com/argoproj/gitops-engine/pkg/sync/resource" + jsonutil "github.com/argoproj/gitops-engine/pkg/utils/json" + gescheme "github.com/argoproj/gitops-engine/pkg/utils/kube/scheme" +) + +const ( + couldNotMarshalErrMsg = "Could not unmarshal to object of type %s: %v" + AnnotationLastAppliedConfig = "kubectl.kubernetes.io/last-applied-configuration" + replacement = "++++++++" +) + +// Holds diffing result of two resources +type DiffResult struct { + // Modified is set to true if resources are not matching + Modified bool + // Contains YAML representation of a live resource with applied normalizations + NormalizedLive []byte + // Contains "expected" YAML representation of a live resource + PredictedLive []byte +} + +// Holds result of two resources sets comparison +type DiffResultList struct { + Diffs []DiffResult + Modified bool +} + +type noopNormalizer struct{} + +func (n *noopNormalizer) Normalize(_ *unstructured.Unstructured) error { + return nil +} + +// Normalizer updates resource before comparing it +type Normalizer interface { + Normalize(un *unstructured.Unstructured) error +} + +// GetNoopNormalizer returns normalizer that does not apply any resource modifications +func GetNoopNormalizer() Normalizer { + return &noopNormalizer{} +} + +// Diff performs a diff on two unstructured objects. If the live object happens to have a +// "kubectl.kubernetes.io/last-applied-configuration", then perform a three way diff. +func Diff(config, live *unstructured.Unstructured, opts ...Option) (*DiffResult, error) { + preDiffOpts := opts + o := applyOptions(opts) + // If server-side diff is enabled, we need to skip full normalization (including ignore differences) + // when pre-processing the config and live objects. + if o.serverSideDiff { + preDiffOpts = append(preDiffOpts, WithSkipFullNormalize(true)) + } + if config != nil { + config = remarshal(config, o) + Normalize(config, preDiffOpts...) + } + if live != nil { + live = remarshal(live, o) + Normalize(live, preDiffOpts...) + } + + if o.serverSideDiff { + r, err := ServerSideDiff(config, live, opts...) + if err != nil { + return nil, fmt.Errorf("error calculating server side diff: %w", err) + } + return r, nil + } + + // TODO The two variables bellow are necessary because there is a cyclic + // dependency with the kube package that blocks the usage of constants + // from common package. common package needs to be refactored and exclude + // dependency from kube. + syncOptAnnotation := "argocd.argoproj.io/sync-options" + ssaAnnotation := "ServerSideApply=true" + + // structuredMergeDiff is mainly used as a feature flag to enable + // calculating diffs using the structured-merge-diff library + // used in k8s while performing server-side applies. It checks the + // given diff Option or if the desired state resource has the + // Server-Side apply sync option annotation enabled. + structuredMergeDiff := o.structuredMergeDiff || + (config != nil && resource.HasAnnotationOption(config, syncOptAnnotation, ssaAnnotation)) + if structuredMergeDiff { + r, err := StructuredMergeDiff(config, live, o.gvkParser, o.manager) + if err != nil { + return nil, fmt.Errorf("error calculating structured merge diff: %w", err) + } + return r, nil + } + orig, err := GetLastAppliedConfigAnnotation(live) + if err != nil { + o.log.V(1).Info(fmt.Sprintf("Failed to get last applied configuration: %v", err)) + } else if orig != nil && config != nil { + Normalize(orig, opts...) + dr, err := ThreeWayDiff(orig, config, live) + if err == nil { + return dr, nil + } + o.log.V(1).Info(fmt.Sprintf("three-way diff calculation failed: %v. Falling back to two-way diff", err)) + } + return TwoWayDiff(config, live) +} + +// ServerSideDiff will execute a k8s server-side apply in dry-run mode with the +// given config. The result will be compared with given live resource to determine +// diff. If config or live are nil it means resource creation or deletion. In this +// no call will be made to kube-api and a simple diff will be returned. +func ServerSideDiff(config, live *unstructured.Unstructured, opts ...Option) (*DiffResult, error) { + if live != nil && config != nil { + result, err := serverSideDiff(config, live, opts...) + if err != nil { + return nil, fmt.Errorf("serverSideDiff error: %w", err) + } + return result, nil + } + // Currently, during resource creation a shallow diff (non ServerSide apply + // based) will be returned. The reasons are: + // - Saves 1 additional call to KubeAPI + // - Much lighter/faster diff + // - This is the existing behaviour users are already used to + // - No direct benefit to the user + result, err := handleResourceCreateOrDeleteDiff(config, live) + if err != nil { + return nil, fmt.Errorf("error handling resource creation or deletion: %w", err) + } + return result, nil +} + +// ServerSideDiff will execute a k8s server-side apply in dry-run mode with the +// given config. The result will be compared with given live resource to determine +// diff. Modifications done by mutation webhooks are removed from the diff by default. +// This behaviour can be customized with Option.WithIgnoreMutationWebhook. +func serverSideDiff(config, live *unstructured.Unstructured, opts ...Option) (*DiffResult, error) { + o := applyOptions(opts) + if o.serverSideDryRunner == nil { + return nil, errors.New("serverSideDryRunner is null") + } + predictedLiveStr, err := o.serverSideDryRunner.Run(context.Background(), config, o.manager) + if err != nil { + return nil, fmt.Errorf("error running server side apply in dryrun mode for resource %s/%s: %w", config.GetKind(), config.GetName(), err) + } + predictedLive, err := jsonStrToUnstructured(predictedLiveStr) + if err != nil { + return nil, fmt.Errorf("error converting json string to unstructured for resource %s/%s: %w", config.GetKind(), config.GetName(), err) + } + + if o.ignoreMutationWebhook { + predictedLive, err = removeWebhookMutation(predictedLive, live, o.gvkParser, o.manager) + if err != nil { + return nil, fmt.Errorf("error removing non config mutations for resource %s/%s: %w", config.GetKind(), config.GetName(), err) + } + } + + Normalize(predictedLive, opts...) + unstructured.RemoveNestedField(predictedLive.Object, "metadata", "managedFields") + + predictedLiveBytes, err := json.Marshal(predictedLive) + if err != nil { + return nil, fmt.Errorf("error marshaling predicted live for resource %s/%s: %w", config.GetKind(), config.GetName(), err) + } + + Normalize(live, opts...) + unstructured.RemoveNestedField(live.Object, "metadata", "managedFields") + liveBytes, err := json.Marshal(live) + if err != nil { + return nil, fmt.Errorf("error marshaling live resource %s/%s: %w", config.GetKind(), config.GetName(), err) + } + return buildDiffResult(predictedLiveBytes, liveBytes), nil +} + +// removeWebhookMutation will compare the predictedLive with live to identify changes done by mutation webhooks. +// Webhook mutations are removed from predictedLive by removing all fields which are not managed by the given 'manager'. +// At this step, we will only have the fields that are managed by the given 'manager'. +// It is then merged with the live state and re-assigned to predictedLive. This means that any +// fields not managed by the specified manager will be reverted with their state from live, including any webhook mutations. +// If the given predictedLive does not have the managedFields, an error will be returned. +func removeWebhookMutation(predictedLive, live *unstructured.Unstructured, gvkParser *managedfields.GvkParser, manager string) (*unstructured.Unstructured, error) { + plManagedFields := predictedLive.GetManagedFields() + if len(plManagedFields) == 0 { + return nil, fmt.Errorf("predictedLive for resource %s/%s must have the managedFields", predictedLive.GetKind(), predictedLive.GetName()) + } + gvk := predictedLive.GetObjectKind().GroupVersionKind() + pt := gvkParser.Type(gvk) + if pt == nil { + return nil, fmt.Errorf("unable to resolve parseableType for GroupVersionKind: %s", gvk) + } + + typedPredictedLive, err := pt.FromUnstructured(predictedLive.Object) + if err != nil { + return nil, fmt.Errorf("error converting predicted live state from unstructured to %s: %w", gvk, err) + } + + typedLive, err := pt.FromUnstructured(live.Object) + if err != nil { + return nil, fmt.Errorf("error converting live state from unstructured to %s: %w", gvk, err) + } + + // Initialize an empty fieldpath.Set to aggregate managed fields for the specified manager + managerFieldsSet := &fieldpath.Set{} + + // Iterate over all ManagedFields entries in predictedLive + for _, mfEntry := range plManagedFields { + managedFieldsSet := &fieldpath.Set{} + err := managedFieldsSet.FromJSON(bytes.NewReader(mfEntry.FieldsV1.Raw)) + if err != nil { + return nil, fmt.Errorf("error building managedFields set: %w", err) + } + if mfEntry.Manager == manager { + // Union the fields with the aggregated set + managerFieldsSet = managerFieldsSet.Union(managedFieldsSet) + } + } + + if managerFieldsSet.Empty() { + return nil, fmt.Errorf("no managed fields found for manager: %s", manager) + } + + predictedLiveFieldSet, err := typedPredictedLive.ToFieldSet() + if err != nil { + return nil, fmt.Errorf("error converting predicted live state to FieldSet: %w", err) + } + + // Remove fields from predicted live that are not managed by the provided manager + nonArgoFieldsSet := predictedLiveFieldSet.Difference(managerFieldsSet) + + // Compare the predicted live with the live resource + comparison, err := typedLive.Compare(typedPredictedLive) + if err != nil { + return nil, fmt.Errorf("error comparing predicted resource to live resource: %w", err) + } + + if comparison.Removed != nil && !comparison.Removed.Empty() { + // exclude the removed fields not owned by this manager from the comparison + comparison.Removed = comparison.Removed.Difference(nonArgoFieldsSet) + } + + // In case any of the removed fields cause schema violations, we will keep those fields + nonArgoFieldsSet = safelyRemoveFieldsSet(typedPredictedLive, nonArgoFieldsSet) + typedPredictedLive = typedPredictedLive.RemoveItems(nonArgoFieldsSet) + + // Apply the predicted live state to the live state to get a diff without mutation webhook fields + typedPredictedLive, err = typedLive.Merge(typedPredictedLive) + + // After applying the predicted live to live state, this would cause any removed fields to be restored. + // We need to re-remove these from predicted live. + typedPredictedLive = typedPredictedLive.RemoveItems(comparison.Removed) + + if err != nil { + return nil, fmt.Errorf("error applying predicted live to live state: %w", err) + } + + plu := typedPredictedLive.AsValue().Unstructured() + pl, ok := plu.(map[string]any) + if !ok { + return nil, fmt.Errorf("error converting live typedValue: expected map got %T", plu) + } + return &unstructured.Unstructured{Object: pl}, nil +} + +// safelyRemoveFieldSet will validate if removing the fieldsToRemove set from predictedLive maintains +// a valid schema. If removing a field in fieldsToRemove is invalid and breaks the schema, it is not safe +// to remove and will be skipped from removal from predictedLive. +func safelyRemoveFieldsSet(predictedLive *typed.TypedValue, fieldsToRemove *fieldpath.Set) *fieldpath.Set { + // In some cases, we cannot remove fields due to violation of the predicted live schema. In such cases we validate the removal + // of each field and only include it if the removal is valid. + testPredictedLive := predictedLive.RemoveItems(fieldsToRemove) + err := testPredictedLive.Validate() + if err != nil { + adjustedFieldsToRemove := fieldpath.NewSet() + fieldsToRemove.Iterate(func(p fieldpath.Path) { + singleFieldSet := fieldpath.NewSet(p) + testSingleRemoval := predictedLive.RemoveItems(singleFieldSet) + // Check if removing this single field maintains a valid schema + if testSingleRemoval.Validate() == nil { + // If valid, add this field to the adjusted set to remove + adjustedFieldsToRemove.Insert(p) + } + }) + return adjustedFieldsToRemove + } + // If no violations, return the original set to remove + return fieldsToRemove +} + +func jsonStrToUnstructured(jsonString string) (*unstructured.Unstructured, error) { + res := make(map[string]any) + err := json.Unmarshal([]byte(jsonString), &res) + if err != nil { + return nil, fmt.Errorf("unmarshal error: %w", err) + } + return &unstructured.Unstructured{Object: res}, nil +} + +// StructuredMergeDiff will calculate the diff using the structured-merge-diff +// k8s library (https://github.com/kubernetes-sigs/structured-merge-diff). +func StructuredMergeDiff(config, live *unstructured.Unstructured, gvkParser *managedfields.GvkParser, manager string) (*DiffResult, error) { + if live != nil && config != nil { + params := &SMDParams{ + config: config, + live: live, + gvkParser: gvkParser, + manager: manager, + } + return structuredMergeDiff(params) + } + return handleResourceCreateOrDeleteDiff(config, live) +} + +// SMDParams defines the parameters required by the structuredMergeDiff +// function +type SMDParams struct { + config *unstructured.Unstructured + live *unstructured.Unstructured + gvkParser *managedfields.GvkParser + manager string +} + +func structuredMergeDiff(p *SMDParams) (*DiffResult, error) { + gvk := p.config.GetObjectKind().GroupVersionKind() + pt := gescheme.ResolveParseableType(gvk, p.gvkParser) + if pt == nil { + return nil, fmt.Errorf("unable to resolve parseableType for GroupVersionKind: %s", gvk) + } + + // Build typed value from live and config unstructures + tvLive, err := pt.FromUnstructured(p.live.Object) + if err != nil { + return nil, fmt.Errorf("error building typed value from live resource: %w", err) + } + tvConfig, err := pt.FromUnstructured(p.config.Object) + if err != nil { + return nil, fmt.Errorf("error building typed value from config resource: %w", err) + } + + // Invoke the apply function to calculate the diff using + // the structured-merge-diff library + mergedLive, err := apply(tvConfig, tvLive, p) + if err != nil { + return nil, fmt.Errorf("error calculating diff: %w", err) + } + + // When mergedLive is nil it means that there is no change + if mergedLive == nil { + liveBytes, err := json.Marshal(p.live) + if err != nil { + return nil, fmt.Errorf("error marshaling live resource: %w", err) + } + // In this case diff result will have live state for both, + // predicted and live. + return buildDiffResult(liveBytes, liveBytes), nil + } + + // Normalize merged live + predictedLive, err := normalizeTypedValue(mergedLive) + if err != nil { + return nil, fmt.Errorf("error applying default values in predicted live: %w", err) + } + + // Normalize live + taintedLive, err := normalizeTypedValue(tvLive) + if err != nil { + return nil, fmt.Errorf("error applying default values in live: %w", err) + } + + return buildDiffResult(predictedLive, taintedLive), nil +} + +// apply will build all the dependency required to invoke the smd.merge.updater.Apply +// to correctly calculate the diff with the same logic used in k8s with server-side +// apply. +func apply(tvConfig, tvLive *typed.TypedValue, p *SMDParams) (*typed.TypedValue, error) { + // Build the structured-merge-diff Updater + updater := merge.Updater{ + Converter: fieldmanager.NewVersionConverter(p.gvkParser, scheme.Scheme, p.config.GroupVersionKind().GroupVersion()), + } + + // Build a list of managers and which API version they own + managed, err := fieldmanager.DecodeManagedFields(p.live.GetManagedFields()) + if err != nil { + return nil, fmt.Errorf("error decoding managed fields: %w", err) + } + + // Use the desired manifest to extract the target resource version + version := fieldpath.APIVersion(p.config.GetAPIVersion()) + + // The manager string needs to be converted to the internal manager + // key used inside structured-merge-diff apply logic + managerKey, err := buildManagerInfoForApply(p.manager) + if err != nil { + return nil, fmt.Errorf("error building manager info: %w", err) + } + + // Finally invoke Apply to execute the same function used in k8s + // server-side applies + mergedLive, _, err := updater.Apply(tvLive, tvConfig, version, managed.Fields(), managerKey, true) + if err != nil { + return nil, fmt.Errorf("error while running updater.Apply: %w", err) + } + return mergedLive, nil +} + +func buildManagerInfoForApply(manager string) (string, error) { + managerInfo := metav1.ManagedFieldsEntry{ + Manager: manager, + Operation: metav1.ManagedFieldsOperationApply, + } + //nolint:wrapcheck // trivial function, wrapped nicely by the caller + return fieldmanager.BuildManagerIdentifier(&managerInfo) +} + +// normalizeTypedValue will prepare the given tv so it can be used in diffs by: +// - removing last-applied-configuration annotation +// - applying default values +func normalizeTypedValue(tv *typed.TypedValue) ([]byte, error) { + ru := tv.AsValue().Unstructured() + r, ok := ru.(map[string]any) + if !ok { + return nil, fmt.Errorf("error converting result typedValue: expected map got %T", ru) + } + resultUn := &unstructured.Unstructured{Object: r} + unstructured.RemoveNestedField(resultUn.Object, "metadata", "annotations", AnnotationLastAppliedConfig) + + resultBytes, err := json.Marshal(resultUn) + if err != nil { + return nil, fmt.Errorf("error while marshaling merged unstructured: %w", err) + } + + obj, err := scheme.Scheme.New(resultUn.GroupVersionKind()) + if err == nil { + err := json.Unmarshal(resultBytes, &obj) + if err != nil { + return nil, fmt.Errorf("error unmarshaling merged bytes into object: %w", err) + } + resultBytes, err = patchDefaultValues(resultBytes, obj) + if err != nil { + return nil, fmt.Errorf("error applying defaults: %w", err) + } + } + return resultBytes, nil +} + +func buildDiffResult(predictedBytes []byte, liveBytes []byte) *DiffResult { + return &DiffResult{ + Modified: string(liveBytes) != string(predictedBytes), + NormalizedLive: liveBytes, + PredictedLive: predictedBytes, + } +} + +// TwoWayDiff performs a three-way diff and uses specified config as a recently applied config +func TwoWayDiff(config, live *unstructured.Unstructured) (*DiffResult, error) { + if live != nil && config != nil { + return ThreeWayDiff(config, config.DeepCopy(), live) + } + return handleResourceCreateOrDeleteDiff(config, live) +} + +// handleResourceCreateOrDeleteDiff will calculate the diff in case of resource creation or +// deletion. Expects that config or live is nil which means that the resource is being +// created or being deleted. Will return error if both are nil or if none are nil. +func handleResourceCreateOrDeleteDiff(config, live *unstructured.Unstructured) (*DiffResult, error) { + if live != nil && config != nil { + return nil, errors.New("unnexpected state: expected live or config to be null: not create or delete operation") + } + if live != nil { + liveData, err := json.Marshal(live) + if err != nil { + return nil, fmt.Errorf("error marshaling live resource: %w", err) + } + return &DiffResult{Modified: false, NormalizedLive: liveData, PredictedLive: []byte("null")}, nil + } else if config != nil { + predictedLiveData, err := json.Marshal(config.Object) + if err != nil { + return nil, fmt.Errorf("error marshaling config resource: %w", err) + } + return &DiffResult{Modified: true, NormalizedLive: []byte("null"), PredictedLive: predictedLiveData}, nil + } + return nil, errors.New("both live and config are null objects") +} + +// generateSchemeDefaultPatch runs the scheme default functions on the given parameter, and +// return a patch representing the delta vs the origin parameter object. +func generateSchemeDefaultPatch(kubeObj runtime.Object) ([]byte, error) { + // 1) Call scheme defaulter functions on a clone of our k8s resource object + patched := kubeObj.DeepCopyObject() + gescheme.Scheme.Default(patched) + + // 2) Compare the original object (pre-defaulter funcs) with patched object (post-default funcs), + // and generate a patch that can be applied against the original + patch, success, err := CreateTwoWayMergePatch(kubeObj, patched, kubeObj.DeepCopyObject()) + + // Ignore empty patch: this only means that kubescheme.Scheme.Default(...) made no changes. + if string(patch) == "{}" && err == nil { + success = true + } + if err != nil || !success { + if err == nil && !success { + err = errors.New("empty result") + } + return nil, err + } + + return patch, err +} + +// applyPatch executes kubernetes server side patch: +// uses corresponding data structure, applies appropriate defaults and executes strategic merge patch +func applyPatch(liveBytes []byte, patchBytes []byte, newVersionedObject func() (runtime.Object, error)) ([]byte, []byte, error) { + // Construct an empty instance of the object we are applying a patch against + predictedLive, err := newVersionedObject() + if err != nil { + return nil, nil, err + } + + // Apply the patchBytes patch against liveBytes, using predictedLive to indicate the k8s data type + predictedLiveBytes, err := strategicpatch.StrategicMergePatch(liveBytes, patchBytes, predictedLive) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct strategic merge patch: %w", err) + } + + // Unmarshal predictedLiveBytes into predictedLive; note that this will discard JSON fields in predictedLiveBytes + // which are not in the predictedLive struct. predictedLive is thus "tainted" and we should not use it directly. + if err = json.Unmarshal(predictedLiveBytes, &predictedLive); err == nil { + // 1) Calls 'kubescheme.Scheme.Default(predictedLive)' and generates a patch containing the delta of that + // call, which can then be applied to predictedLiveBytes. + // + // Why do we do this? Since predictedLive is "tainted" (missing extra fields), we cannot use it to populate + // predictedLiveBytes, BUT we still need predictedLive itself in order to call the default scheme functions. + // So, we call the default scheme functions on the "tainted" struct, to generate a patch, and then + // apply that patch to the untainted JSON. + patch, err := generateSchemeDefaultPatch(predictedLive) + if err != nil { + return nil, nil, err + } + + // 2) Apply the default-funcs patch against the original "untainted" JSON + // This allows us to apply the scheme default values generated above, against JSON that does not fully conform + // to its k8s resource type (eg the JSON may contain those invalid fields that we do not wish to discard). + predictedLiveBytes, err = strategicpatch.StrategicMergePatch(predictedLiveBytes, patch, predictedLive.DeepCopyObject()) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct strategic merge patch for predicted state: %w", err) + } + + // 3) Unmarshall into a map[string]any, then back into byte[], to ensure the fields + // are sorted in a consistent order (we do the same below, so that they can be + // lexicographically compared with one another) + var result map[string]any + err = json.Unmarshal([]byte(predictedLiveBytes), &result) + if err != nil { + return nil, nil, fmt.Errorf("failed to unmarshal strategic merge patch for predicted state: %w", err) + } + predictedLiveBytes, err = json.Marshal(result) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal strategic merge patch for predicted state: %w", err) + } + } + + live, err := newVersionedObject() + if err != nil { + return nil, nil, err + } + + // As above, unknown JSON fields in liveBytes will be discarded in the unmarshalling to 'live'. + // However, this is much less likely since liveBytes is coming from a live k8s instance which + // has already accepted those resources. Regardless, we still treat 'live' as tainted. + if err = json.Unmarshal(liveBytes, live); err == nil { + // As above, indirectly apply the schema defaults against liveBytes + patch, err := generateSchemeDefaultPatch(live) + if err != nil { + return nil, nil, err + } + liveBytes, err = strategicpatch.StrategicMergePatch(liveBytes, patch, live.DeepCopyObject()) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct strategic merge patch for live state: %w", err) + } + + // Ensure the fields are sorted in a consistent order (as above) + var result map[string]any + err = json.Unmarshal([]byte(liveBytes), &result) + if err != nil { + return nil, nil, fmt.Errorf("failed to unmarshal strategic merge patch for live state: %w", err) + } + liveBytes, err = json.Marshal(result) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal strategic merge patch for live state: %w", err) + } + } + + return liveBytes, predictedLiveBytes, nil +} + +// patchDefaultValues will calculate the default values patch based on the +// given obj. It will apply the patch using the given objBytes and return +// the new patched object. +func patchDefaultValues(objBytes []byte, obj runtime.Object) ([]byte, error) { + // 1) Call 'kubescheme.Scheme.Default(obj)' to generate a patch containing + // the default values for the given scheme. + patch, err := generateSchemeDefaultPatch(obj) + if err != nil { + return nil, fmt.Errorf("error generating patch for default values: %w", err) + } + + // 2) Apply the patch with default values in objBytes. + patchedBytes, err := strategicpatch.StrategicMergePatch(objBytes, patch, obj) + if err != nil { + return nil, fmt.Errorf("error applying patch for default values: %w", err) + } + + // 3) Unmarshall into a map[string]any, then back into byte[], to + // ensure the fields are sorted in a consistent order (we do the same below, + // so that they can be lexicographically compared with one another). + var result map[string]any + err = json.Unmarshal([]byte(patchedBytes), &result) + if err != nil { + return nil, fmt.Errorf("error unmarshaling patched bytes: %w", err) + } + patchedBytes, err = json.Marshal(result) + if err != nil { + return nil, fmt.Errorf("error marshaling patched bytes: %w", err) + } + + return patchedBytes, nil +} + +// ThreeWayDiff performs a diff with the understanding of how to incorporate the +// last-applied-configuration annotation in the diff. +// Inputs are assumed to be stripped of type information +func ThreeWayDiff(orig, config, live *unstructured.Unstructured) (*DiffResult, error) { + orig = removeNamespaceAnnotation(orig) + config = removeNamespaceAnnotation(config) + + // 1. calculate a 3-way merge patch + patchBytes, newVersionedObject, err := threeWayMergePatch(orig, config, live) + if err != nil { + return nil, err + } + + // 2. get expected live object by applying the patch against the live object + liveBytes, err := json.Marshal(live) + if err != nil { + return nil, fmt.Errorf("failed to marshal live state: %w", err) + } + + var predictedLiveBytes []byte + // If orig/config/live represents a registered scheme... + if newVersionedObject != nil { + // Apply patch while applying scheme defaults + liveBytes, predictedLiveBytes, err = applyPatch(liveBytes, patchBytes, newVersionedObject) + if err != nil { + return nil, err + } + } else { + // Otherwise, merge patch directly as JSON + predictedLiveBytes, err = jsonpatch.MergePatch(liveBytes, patchBytes) + if err != nil { + return nil, fmt.Errorf("failed to construct merge patch for predicted state: %w", err) + } + } + + return buildDiffResult(predictedLiveBytes, liveBytes), nil +} + +// removeNamespaceAnnotation remove the namespace and an empty annotation map from the metadata. +// The namespace field is present in live (namespaced) objects, but not necessarily present in +// config or last-applied. This results in a diff which we don't care about. We delete the two so +// that the diff is more relevant. +func removeNamespaceAnnotation(orig *unstructured.Unstructured) *unstructured.Unstructured { + orig = orig.DeepCopy() + if metadataIf, ok := orig.Object["metadata"]; ok { + metadata := metadataIf.(map[string]any) + delete(metadata, "namespace") + if annotationsIf, ok := metadata["annotations"]; ok { + shouldDelete := false + if annotationsIf == nil { + shouldDelete = true + } else { + annotation, ok := annotationsIf.(map[string]any) + if ok && len(annotation) == 0 { + shouldDelete = true + } + } + if shouldDelete { + delete(metadata, "annotations") + } + } + } + return orig +} + +// StatefulSet requires special handling since it embeds PersistentVolumeClaim resource. +// K8S API server applies additional default field which we cannot reproduce on client side. +// So workaround is to remove all "defaulted" fields from 'volumeClaimTemplates' of live resource. +func statefulSetWorkaround(orig, live *unstructured.Unstructured) *unstructured.Unstructured { + origTemplate, ok, err := unstructured.NestedSlice(orig.Object, "spec", "volumeClaimTemplates") + if !ok || err != nil { + return live + } + + liveTemplate, ok, err := unstructured.NestedSlice(live.Object, "spec", "volumeClaimTemplates") + if !ok || err != nil { + return live + } + live = live.DeepCopy() + + _ = unstructured.SetNestedField(live.Object, jsonutil.RemoveListFields(origTemplate, liveTemplate), "spec", "volumeClaimTemplates") + return live +} + +func threeWayMergePatch(orig, config, live *unstructured.Unstructured) ([]byte, func() (runtime.Object, error), error) { + origBytes, err := json.Marshal(orig.Object) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal original object: %w", err) + } + configBytes, err := json.Marshal(config.Object) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal config object: %w", err) + } + + if versionedObject, err := scheme.Scheme.New(orig.GroupVersionKind()); err == nil { + gk := orig.GroupVersionKind().GroupKind() + if (gk.Group == "apps" || gk.Group == "extensions") && gk.Kind == "StatefulSet" { + live = statefulSetWorkaround(orig, live) + } + + liveBytes, err := json.Marshal(live.Object) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal live object: %w", err) + } + + lookupPatchMeta, err := strategicpatch.NewPatchMetaFromStruct(versionedObject) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct lookup patch: %w", err) + } + patch, err := strategicpatch.CreateThreeWayMergePatch(origBytes, configBytes, liveBytes, lookupPatchMeta, true) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct thre way merge patch: %w", err) + } + newVersionedObject := func() (runtime.Object, error) { + return scheme.Scheme.New(orig.GroupVersionKind()) + } + return patch, newVersionedObject, nil + } + // Remove defaulted fields from the live object. + // This subtracts any extra fields in the live object which are not present in last-applied-configuration. + live = &unstructured.Unstructured{Object: jsonutil.RemoveMapFields(orig.Object, live.Object)} + + liveBytes, err := json.Marshal(live.Object) + if err != nil { + return nil, nil, fmt.Errorf("failed to marshal live object: %w", err) + } + + patch, err := jsonmergepatch.CreateThreeWayJSONMergePatch(origBytes, configBytes, liveBytes) + if err != nil { + return nil, nil, fmt.Errorf("failed to construct thre way merge patch: %w", err) + } + return patch, nil, nil +} + +func GetLastAppliedConfigAnnotation(live *unstructured.Unstructured) (*unstructured.Unstructured, error) { + if live == nil { + return nil, nil + } + annotations := live.GetAnnotations() + lastAppliedStr, ok := annotations[corev1.LastAppliedConfigAnnotation] + if !ok { + return nil, nil + } + var obj unstructured.Unstructured + err := json.Unmarshal([]byte(lastAppliedStr), &obj) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal %s in %s: %w", corev1.LastAppliedConfigAnnotation, live.GetName(), err) + } + return &obj, nil +} + +// DiffArray performs a diff on a list of unstructured objects. Objects are expected to match +// environments +func DiffArray(configArray, liveArray []*unstructured.Unstructured, opts ...Option) (*DiffResultList, error) { + numItems := len(configArray) + if len(liveArray) != numItems { + return nil, errors.New("left and right arrays have mismatched lengths") + } + + diffResultList := DiffResultList{ + Diffs: make([]DiffResult, numItems), + } + for i := 0; i < numItems; i++ { + config := configArray[i] + live := liveArray[i] + diffRes, err := Diff(config, live, opts...) + if err != nil { + return nil, err + } + diffResultList.Diffs[i] = *diffRes + if diffRes.Modified { + diffResultList.Modified = true + } + } + return &diffResultList, nil +} + +func Normalize(un *unstructured.Unstructured, opts ...Option) { + if un == nil { + return + } + o := applyOptions(opts) + + // creationTimestamp is sometimes set to null in the config when exported (e.g. SealedSecrets) + // Removing the field allows a cleaner diff. + unstructured.RemoveNestedField(un.Object, "metadata", "creationTimestamp") + + gvk := un.GroupVersionKind() + switch { + case gvk.Group == "" && gvk.Kind == "Secret": + NormalizeSecret(un, opts...) + case gvk.Group == "rbac.authorization.k8s.io" && (gvk.Kind == "ClusterRole" || gvk.Kind == "Role"): + normalizeRole(un, o) + case gvk.Group == "" && gvk.Kind == "Endpoints": + normalizeEndpoint(un, o) + } + + // Skip the full normalization (ignoreDifferences + knownTypes) for server-side diff + // In the case an ignoreDifferences field is required, it needs to be present in the config + // before server-side diff is calculated and normalized before final comparison. + if !o.skipFullNormalize { + err := o.normalizer.Normalize(un) + if err != nil { + o.log.Error(err, fmt.Sprintf("Failed to normalize %s/%s/%s", un.GroupVersionKind(), un.GetNamespace(), un.GetName())) + } + } +} + +// NormalizeSecret mutates the supplied object and encodes stringData to data, and converts nils to +// empty strings. If the object is not a secret, or is an invalid secret, then returns the same object. +func NormalizeSecret(un *unstructured.Unstructured, opts ...Option) { + if un == nil { + return + } + gvk := un.GroupVersionKind() + if gvk.Group != "" || gvk.Kind != "Secret" { + return + } + + // move stringData to data section + if stringData, found, err := unstructured.NestedMap(un.Object, "stringData"); found && err == nil { + var data map[string]any + data, found, _ = unstructured.NestedMap(un.Object, "data") + if !found { + data = make(map[string]any) + } + + // base64 encode string values and add non-string values as is. + // This ensures that the apply fails if the secret is invalid. + for k, v := range stringData { + strVal, ok := v.(string) + if ok { + data[k] = base64.StdEncoding.EncodeToString([]byte(strVal)) + } else { + data[k] = v + } + } + + err := unstructured.SetNestedField(un.Object, data, "data") + if err == nil { + delete(un.Object, "stringData") + } + } + + o := applyOptions(opts) + var secret corev1.Secret + err := runtime.DefaultUnstructuredConverter.FromUnstructured(un.Object, &secret) + if err != nil { + o.log.Error(err, "Failed to convert from unstructured into Secret") + return + } + // We normalize nils to empty string to handle: https://github.com/argoproj/argo-cd/issues/943 + for k, v := range secret.Data { + if len(v) == 0 { + secret.Data[k] = []byte("") + } + } + newObj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&secret) + if err != nil { + o.log.Error(err, "object unable to convert from secret") + return + } + if secret.Data != nil { + err = unstructured.SetNestedField(un.Object, newObj["data"], "data") + if err != nil { + o.log.Error(err, "failed to set secret.data") + return + } + } +} + +// normalizeEndpoint normalizes endpoint meaning that EndpointSubsets are sorted lexicographically +func normalizeEndpoint(un *unstructured.Unstructured, o options) { + if un == nil { + return + } + gvk := un.GroupVersionKind() + if gvk.Group != "" || gvk.Kind != "Endpoints" { + return + } + //nolint:staticcheck // SA1019: corev1.Endpoints is deprecated in v1.33+, but we need to keep it for backward compatibility + var ep corev1.Endpoints + err := runtime.DefaultUnstructuredConverter.FromUnstructured(un.Object, &ep) + if err != nil { + o.log.Error(err, "Failed to convert from unstructured into Endpoints") + return + } + + // add default protocol to subsets ports if it is empty + for s := range ep.Subsets { + subset := &ep.Subsets[s] + for p := range subset.Ports { + port := &subset.Ports[p] + if port.Protocol == "" { + port.Protocol = corev1.ProtocolTCP + } + } + } + + endpoints.SortSubsets(ep.Subsets) + + newObj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&ep) + if err != nil { + o.log.Info(fmt.Sprintf(couldNotMarshalErrMsg, gvk, err)) + return + } + un.Object = newObj +} + +// normalizeRole mutates the supplied Role/ClusterRole and sets rules to null if it is an empty list or an aggregated role +func normalizeRole(un *unstructured.Unstructured, o options) { + if un == nil { + return + } + gvk := un.GroupVersionKind() + if gvk.Group != "rbac.authorization.k8s.io" || (gvk.Kind != "Role" && gvk.Kind != "ClusterRole") { + return + } + + // Check whether the role we're checking is an aggregation role. If it is, we ignore any differences in rules. + if o.ignoreAggregatedRoles { + aggrIf, ok := un.Object["aggregationRule"] + if ok { + _, ok = aggrIf.(map[string]any) + if !ok { + o.log.Info(fmt.Sprintf("Malformed aggregationRule in resource '%s', won't modify.", un.GetName())) + } else { + un.Object["rules"] = nil + } + } + } + + rulesIf, ok := un.Object["rules"] + if !ok { + return + } + rules, ok := rulesIf.([]any) + if !ok { + return + } + if rules != nil && len(rules) == 0 { + un.Object["rules"] = nil + } +} + +// CreateTwoWayMergePatch is a helper to construct a two-way merge patch from objects (instead of bytes) +func CreateTwoWayMergePatch(orig, new, dataStruct any) ([]byte, bool, error) { + origBytes, err := json.Marshal(orig) + if err != nil { + return nil, false, fmt.Errorf("failed to marshal orig object: %w", err) + } + newBytes, err := json.Marshal(new) + if err != nil { + return nil, false, fmt.Errorf("failed to marshal new object: %w", err) + } + patch, err := strategicpatch.CreateTwoWayMergePatch(origBytes, newBytes, dataStruct) + if err != nil { + return nil, false, fmt.Errorf("failed to create two way merge patch: %w", err) + } + return patch, string(patch) != "{}", nil +} + +// HideSecretData replaces secret data & optional annotations values in specified target, live secrets and in last applied configuration of live secret with plus(+). Also preserves differences between +// target, live and last applied config values. E.g. if all three are equal the values would be replaced with same number of plus(+). If all are different then number of plus(+) +// in replacement should be different. +func HideSecretData(target *unstructured.Unstructured, live *unstructured.Unstructured, hideAnnotations map[string]bool) (*unstructured.Unstructured, *unstructured.Unstructured, error) { + var liveLastAppliedAnnotation *unstructured.Unstructured + if live != nil { + liveLastAppliedAnnotation, _ = GetLastAppliedConfigAnnotation(live) + live = live.DeepCopy() + } + if target != nil { + target = target.DeepCopy() + } + + keys := map[string]bool{} + for _, obj := range []*unstructured.Unstructured{target, live, liveLastAppliedAnnotation} { + if obj == nil { + continue + } + NormalizeSecret(obj) + if data, found, err := unstructured.NestedMap(obj.Object, "data"); found && err == nil { + for k := range data { + keys[k] = true + } + } + } + + var err error + target, live, liveLastAppliedAnnotation, err = hide(target, live, liveLastAppliedAnnotation, keys, "data") + if err != nil { + return nil, nil, err + } + + target, live, liveLastAppliedAnnotation, err = hide(target, live, liveLastAppliedAnnotation, hideAnnotations, "metadata", "annotations") + if err != nil { + return nil, nil, err + } + + if live != nil && liveLastAppliedAnnotation != nil { + annotations := live.GetAnnotations() + if annotations == nil { + annotations = make(map[string]string) + } + // special case: hide "kubectl.kubernetes.io/last-applied-configuration" annotation + if _, ok := hideAnnotations[corev1.LastAppliedConfigAnnotation]; ok { + annotations[corev1.LastAppliedConfigAnnotation] = replacement + } else { + lastAppliedData, err := json.Marshal(liveLastAppliedAnnotation) + if err != nil { + return nil, nil, fmt.Errorf("error marshaling json: %w", err) + } + annotations[corev1.LastAppliedConfigAnnotation] = string(lastAppliedData) + } + live.SetAnnotations(annotations) + } + return target, live, nil +} + +func hide(target, live, liveLastAppliedAnnotation *unstructured.Unstructured, keys map[string]bool, fields ...string) (*unstructured.Unstructured, *unstructured.Unstructured, *unstructured.Unstructured, error) { + for k := range keys { + // we use "+" rather than the more common "*" + nextReplacement := replacement + valToReplacement := make(map[string]string) + for _, obj := range []*unstructured.Unstructured{target, live, liveLastAppliedAnnotation} { + var data map[string]any + if obj != nil { + // handles an edge case when secret data has nil value + // https://github.com/argoproj/argo-cd/issues/5584 + dataValue, ok, _ := unstructured.NestedFieldCopy(obj.Object, fields...) + if ok { + if dataValue == nil { + continue + } + } + var err error + data, _, err = unstructured.NestedMap(obj.Object, fields...) + if err != nil { + return nil, nil, nil, fmt.Errorf("unstructured.NestedMap error: %w", err) + } + } + if data == nil { + data = make(map[string]any) + } + valData, ok := data[k] + if !ok { + continue + } + val := toString(valData) + replacement, ok := valToReplacement[val] + if !ok { + replacement = nextReplacement + nextReplacement = nextReplacement + "++++" + valToReplacement[val] = replacement + } + data[k] = replacement + err := unstructured.SetNestedField(obj.Object, data, fields...) + if err != nil { + return nil, nil, nil, fmt.Errorf("unstructured.SetNestedField error: %w", err) + } + } + } + return target, live, liveLastAppliedAnnotation, nil +} + +func toString(val any) string { + if val == nil { + return "" + } + return fmt.Sprintf("%s", val) +} + +// remarshal checks resource kind and version and re-marshal using corresponding struct custom marshaller. +// This ensures that expected resource state is formatter same as actual resource state in kubernetes +// and allows to find differences between actual and target states more accurately. +// Remarshalling also strips any type information (e.g. float64 vs. int) from the unstructured +// object. This is important for diffing since it will cause godiff to report a false difference. +func remarshal(obj *unstructured.Unstructured, o options) *unstructured.Unstructured { + data, err := json.Marshal(obj) + if err != nil { + panic(err) + } + + // Unmarshal again to strip type information (e.g. float64 vs. int) from the unstructured + // object. This is important for diffing since it will cause godiff to report a false difference. + var newUn unstructured.Unstructured + err = json.Unmarshal(data, &newUn) + if err != nil { + panic(err) + } + obj = &newUn + + gvk := obj.GroupVersionKind() + item, err := scheme.Scheme.New(obj.GroupVersionKind()) + if err != nil { + // This is common. the scheme is not registered + o.log.V(1).Info(fmt.Sprintf("Could not create new object of type %s: %v", gvk, err)) + return obj + } + // This will drop any omitempty fields, perform resource conversion etc... + unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface() + // Unmarshal data into unmarshalledObj, but detect if there are any unknown fields that are not + // found in the target GVK object. + decoder := json.NewDecoder(bytes.NewReader(data)) + decoder.DisallowUnknownFields() + if err := decoder.Decode(&unmarshalledObj); err != nil { + // Likely a field present in obj that is not present in the GVK type, or user + // may have specified an invalid spec in git, so return original object + o.log.V(1).Info(fmt.Sprintf(couldNotMarshalErrMsg, gvk, err)) + return obj + } + unstrBody, err := runtime.DefaultUnstructuredConverter.ToUnstructured(unmarshalledObj) + if err != nil { + o.log.V(1).Info(fmt.Sprintf(couldNotMarshalErrMsg, gvk, err)) + return obj + } + // Remove all default values specified by custom formatter (e.g. creationTimestamp) + unstrBody = jsonutil.RemoveMapFields(obj.Object, unstrBody) + return &unstructured.Unstructured{Object: unstrBody} +} diff --git a/gitops-engine/pkg/diff/diff_options.go b/gitops-engine/pkg/diff/diff_options.go new file mode 100644 index 0000000000000..1d5f12a519fcb --- /dev/null +++ b/gitops-engine/pkg/diff/diff_options.go @@ -0,0 +1,133 @@ +package diff + +import ( + "context" + + "github.com/go-logr/logr" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/klog/v2/textlogger" + cmdutil "k8s.io/kubectl/pkg/cmd/util" +) + +type Option func(*options) + +// Holds diffing settings +type options struct { + // If set to true then differences caused by aggregated roles in RBAC resources are ignored. + ignoreAggregatedRoles bool + normalizer Normalizer + skipFullNormalize bool + log logr.Logger + structuredMergeDiff bool + gvkParser *managedfields.GvkParser + manager string + serverSideDiff bool + serverSideDryRunner ServerSideDryRunner + ignoreMutationWebhook bool +} + +func applyOptions(opts []Option) options { + o := options{ + ignoreAggregatedRoles: false, + ignoreMutationWebhook: true, + normalizer: GetNoopNormalizer(), + skipFullNormalize: false, + log: textlogger.NewLogger(textlogger.NewConfig()), + } + for _, opt := range opts { + opt(&o) + } + return o +} + +type KubeApplier interface { + ApplyResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force, validate, serverSideApply bool, manager string) (string, error) +} + +// ServerSideDryRunner defines the contract to run a server-side apply in +// dryrun mode. +type ServerSideDryRunner interface { + Run(ctx context.Context, obj *unstructured.Unstructured, manager string) (string, error) +} + +// K8sServerSideDryRunner is the Kubernetes implementation of ServerSideDryRunner. +type K8sServerSideDryRunner struct { + dryrunApplier KubeApplier +} + +// NewK8sServerSideDryRunner will instantiate a new K8sServerSideDryRunner with +// the given kubeApplier. +func NewK8sServerSideDryRunner(kubeApplier KubeApplier) *K8sServerSideDryRunner { + return &K8sServerSideDryRunner{ + dryrunApplier: kubeApplier, + } +} + +// ServerSideApplyDryRun will invoke a kubernetes server-side apply with the given +// obj and the given manager in dryrun mode. Will return the predicted live state +// json as string. +func (kdr *K8sServerSideDryRunner) Run(ctx context.Context, obj *unstructured.Unstructured, manager string) (string, error) { + //nolint:wrapcheck // trivial function, don't bother wrapping + return kdr.dryrunApplier.ApplyResource(ctx, obj, cmdutil.DryRunServer, false, false, true, manager) +} + +func IgnoreAggregatedRoles(ignore bool) Option { + return func(o *options) { + o.ignoreAggregatedRoles = ignore + } +} + +func WithNormalizer(normalizer Normalizer) Option { + return func(o *options) { + o.normalizer = normalizer + } +} + +func WithSkipFullNormalize(skip bool) Option { + return func(o *options) { + o.skipFullNormalize = skip + } +} + +func WithLogr(log logr.Logger) Option { + return func(o *options) { + o.log = log + } +} + +func WithStructuredMergeDiff(smd bool) Option { + return func(o *options) { + o.structuredMergeDiff = smd + } +} + +func WithGVKParser(parser *managedfields.GvkParser) Option { + return func(o *options) { + o.gvkParser = parser + } +} + +func WithManager(manager string) Option { + return func(o *options) { + o.manager = manager + } +} + +func WithServerSideDiff(ssd bool) Option { + return func(o *options) { + o.serverSideDiff = ssd + } +} + +func WithIgnoreMutationWebhook(mw bool) Option { + return func(o *options) { + o.ignoreMutationWebhook = mw + } +} + +func WithServerSideDryRunner(ssadr ServerSideDryRunner) Option { + return func(o *options) { + o.serverSideDryRunner = ssadr + } +} diff --git a/gitops-engine/pkg/diff/diff_test.go b/gitops-engine/pkg/diff/diff_test.go new file mode 100644 index 0000000000000..cf2c3c30c915c --- /dev/null +++ b/gitops-engine/pkg/diff/diff_test.go @@ -0,0 +1,1810 @@ +package diff + +import ( + "context" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" + + openapi_v2 "github.com/google/gnostic-models/openapiv2" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/equality" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/intstr" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/klog/v2/textlogger" + openapiproto "k8s.io/kube-openapi/pkg/util/proto" + "sigs.k8s.io/yaml" + + "github.com/argoproj/gitops-engine/pkg/diff/mocks" + "github.com/argoproj/gitops-engine/pkg/diff/testdata" +) + +func printDiff(result *DiffResult) (string, error) { + var live unstructured.Unstructured + if err := json.Unmarshal(result.NormalizedLive, &live); err != nil { + return "", fmt.Errorf("failed to unmarshal live object: %w", err) + } + var target unstructured.Unstructured + if err := json.Unmarshal(result.PredictedLive, &target); err != nil { + return "", fmt.Errorf("failed to unmarshal target object: %w", err) + } + out, _ := printDiffInternal("diff", &live, &target) + return string(out), nil +} + +// printDiffInternal prints a diff between two unstructured objects using an external diff utility and returns the output. +func printDiffInternal(name string, live *unstructured.Unstructured, target *unstructured.Unstructured) ([]byte, error) { + tempDir, err := os.MkdirTemp("", "argocd-diff") + if err != nil { + return nil, fmt.Errorf("failed to create temp directory: %w", err) + } + targetFile := filepath.Join(tempDir, name) + var targetData []byte + if target != nil { + targetData, err = yaml.Marshal(target) + if err != nil { + return nil, fmt.Errorf("failed to marshal target object: %w", err) + } + } + err = os.WriteFile(targetFile, targetData, 0o644) + if err != nil { + return nil, fmt.Errorf("failed to write target object: %w", err) + } + liveFile := filepath.Join(tempDir, name+"-live.yaml") + liveData := []byte("") + if live != nil { + liveData, err = yaml.Marshal(live) + if err != nil { + return nil, fmt.Errorf("failed to marshal live object: %w", err) + } + } + err = os.WriteFile(liveFile, liveData, 0o644) + if err != nil { + return nil, fmt.Errorf("failed to write live object: %w", err) + } + cmd := exec.Command("diff", liveFile, targetFile) + out, err := cmd.Output() + if err != nil { + // return output even if there's an error + return out, fmt.Errorf("failed to diff live object: %w", err) + } + return out, nil +} + +func toUnstructured(obj any) (*unstructured.Unstructured, error) { + uObj, err := runtime.NewTestUnstructuredConverter(equality.Semantic).ToUnstructured(obj) + if err != nil { + //nolint:wrapcheck // don't wrap, trivial function + return nil, err + } + return &unstructured.Unstructured{Object: uObj}, nil +} + +func mustToUnstructured(obj any) *unstructured.Unstructured { + un, err := toUnstructured(obj) + if err != nil { + panic(err) + } + return un +} + +func unmarshalFile(path string) *unstructured.Unstructured { + data, err := os.ReadFile(path) + if err != nil { + panic(err) + } + var un unstructured.Unstructured + err = json.Unmarshal(data, &un.Object) + if err != nil { + panic(err) + } + return &un +} + +func newDeployment() *appsv1.Deployment { + var two int32 = 2 + return &appsv1.Deployment{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apps/v1beta1", + Kind: "Deployment", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "demo", + Namespace: "test", + }, + Spec: appsv1.DeploymentSpec{ + Replicas: &two, + Selector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "app": "demo", + }, + }, + Template: corev1.PodTemplateSpec{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "app": "demo", + }, + }, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + { + Name: "demo", + Image: "gcr.io/kuar-demo/kuard-amd64:1", + Ports: []corev1.ContainerPort{ + { + ContainerPort: 80, + }, + }, + }, + }, + }, + }, + }, + } +} + +func diff(t *testing.T, config, live *unstructured.Unstructured, options ...Option) *DiffResult { + t.Helper() + res, err := Diff(config, live, options...) + assert.NoError(t, err) + return res +} + +func TestDiff(t *testing.T) { + leftDep := newDeployment() + leftUn := mustToUnstructured(leftDep) + + diffRes := diff(t, leftUn, leftUn, diffOptionsForTest()...) + assert.False(t, diffRes.Modified) + ascii, err := printDiff(diffRes) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } +} + +func TestDiff_KnownTypeInvalidValue(t *testing.T) { + leftDep := newDeployment() + leftUn := mustToUnstructured(leftDep) + require.NoError(t, unstructured.SetNestedField(leftUn.Object, "badValue", "spec", "revisionHistoryLimit")) + + t.Run("NoDifference", func(t *testing.T) { + diffRes := diff(t, leftUn, leftUn, diffOptionsForTest()...) + assert.False(t, diffRes.Modified) + ascii, err := printDiff(diffRes) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } + }) + + t.Run("HasDifference", func(t *testing.T) { + rightUn := leftUn.DeepCopy() + require.NoError(t, unstructured.SetNestedField(rightUn.Object, "3", "spec", "revisionHistoryLimit")) + + diffRes := diff(t, leftUn, rightUn, diffOptionsForTest()...) + assert.True(t, diffRes.Modified) + }) +} + +func TestDiffWithNils(t *testing.T) { + dep := newDeployment() + resource := mustToUnstructured(dep) + + diffRes := diff(t, nil, resource, diffOptionsForTest()...) + // NOTE: if live is non-nil, and config is nil, this is not considered difference + // This "difference" is checked at the comparator. + assert.False(t, diffRes.Modified) + diffRes, err := TwoWayDiff(nil, resource) + require.NoError(t, err) + assert.False(t, diffRes.Modified) + + diffRes = diff(t, resource, nil, diffOptionsForTest()...) + assert.True(t, diffRes.Modified) + diffRes, err = TwoWayDiff(resource, nil) + require.NoError(t, err) + assert.True(t, diffRes.Modified) +} + +func TestDiffNilFieldInLive(t *testing.T) { + leftDep := newDeployment() + rightDep := leftDep.DeepCopy() + + leftUn := mustToUnstructured(leftDep) + rightUn := mustToUnstructured(rightDep) + err := unstructured.SetNestedField(rightUn.Object, nil, "spec") + require.NoError(t, err) + + diffRes := diff(t, leftUn, rightUn, diffOptionsForTest()...) + assert.True(t, diffRes.Modified) +} + +func TestDiffArraySame(t *testing.T) { + leftDep := newDeployment() + rightDep := leftDep.DeepCopy() + + leftUn := mustToUnstructured(leftDep) + rightUn := mustToUnstructured(rightDep) + + left := []*unstructured.Unstructured{leftUn} + right := []*unstructured.Unstructured{rightUn} + diffResList, err := DiffArray(left, right, diffOptionsForTest()...) + require.NoError(t, err) + assert.False(t, diffResList.Modified) +} + +func TestDiffArrayAdditions(t *testing.T) { + leftDep := newDeployment() + rightDep := leftDep.DeepCopy() + rightDep.Status.Replicas = 1 + + leftUn := mustToUnstructured(leftDep) + rightUn := mustToUnstructured(rightDep) + + left := []*unstructured.Unstructured{leftUn} + right := []*unstructured.Unstructured{rightUn} + diffResList, err := DiffArray(left, right, diffOptionsForTest()...) + require.NoError(t, err) + assert.False(t, diffResList.Modified) +} + +func TestDiffArrayModification(t *testing.T) { + leftDep := newDeployment() + rightDep := leftDep.DeepCopy() + ten := int32(10) + rightDep.Spec.Replicas = &ten + + leftUn := mustToUnstructured(leftDep) + rightUn := mustToUnstructured(rightDep) + + left := []*unstructured.Unstructured{leftUn} + right := []*unstructured.Unstructured{rightUn} + diffResList, err := DiffArray(left, right, diffOptionsForTest()...) + require.NoError(t, err) + assert.True(t, diffResList.Modified) +} + +// TestThreeWayDiff will perform a diff when there is a kubectl.kubernetes.io/last-applied-configuration +// present in the live object. +func TestThreeWayDiff(t *testing.T) { + // 1. get config and live to be the same. Both have a foo annotation. + configDep := newDeployment() + configDep.Namespace = "" + configDep.Annotations = map[string]string{ + "foo": "bar", + } + liveDep := configDep.DeepCopy() + + // 2. add a extra field to the live. this simulates kubernetes adding default values in the + // object. We should not consider defaulted values as a difference + liveDep.SetNamespace("default") + configUn := mustToUnstructured(configDep) + liveUn := mustToUnstructured(liveDep) + res := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, res.Modified) { + ascii, err := printDiff(res) + require.NoError(t, err) + t.Log(ascii) + } + + // 3. Add a last-applied-configuration annotation in the live. There should still not be any + // difference + configBytes, err := json.Marshal(configDep) + require.NoError(t, err) + liveDep.Annotations[corev1.LastAppliedConfigAnnotation] = string(configBytes) + configUn = mustToUnstructured(configDep) + liveUn = mustToUnstructured(liveDep) + res = diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, res.Modified) { + ascii, err := printDiff(res) + require.NoError(t, err) + t.Log(ascii) + } + + // 4. Remove the foo annotation from config and perform the diff again. We should detect a + // difference since three-way diff detects the removal of a managed field + delete(configDep.Annotations, "foo") + configUn = mustToUnstructured(configDep) + liveUn = mustToUnstructured(liveDep) + res = diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.True(t, res.Modified) + + // 5. Just to prove three way diff incorporates last-applied-configuration, remove the + // last-applied-configuration annotation from the live object, and redo the diff. This time, + // the diff will report not modified (because we have no way of knowing what was a defaulted + // field without this annotation) + delete(liveDep.Annotations, corev1.LastAppliedConfigAnnotation) + configUn = mustToUnstructured(configDep) + liveUn = mustToUnstructured(liveDep) + res = diff(t, configUn, liveUn, diffOptionsForTest()...) + ascii, err := printDiff(res) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } + assert.False(t, res.Modified) +} + +var demoConfig = ` +{ + "apiVersion": "v1", + "kind": "ServiceAccount", + "metadata": { + "labels": { + "app.kubernetes.io/instance": "argocd-demo" + }, + "name": "argocd-application-controller" + } +} +` + +var demoLive = ` +{ + "apiVersion": "v1", + "kind": "ServiceAccount", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"v1\",\"kind\":\"ServiceAccount\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"argocd-demo\"},\"name\":\"argocd-application-controller\",\"namespace\":\"argocd-demo\"}}\n" + }, + "creationTimestamp": "2018-04-16T22:08:57Z", + "labels": { + "app.kubernetes.io/instance": "argocd-demo" + }, + "name": "argocd-application-controller", + "namespace": "argocd-demo", + "resourceVersion": "7584502", + "selfLink": "/api/v1/namespaces/argocd-demo/serviceaccounts/argocd-application-controller", + "uid": "c22bb2b4-41c2-11e8-978a-028445d52ec8" + }, + "secrets": [ + { + "name": "argocd-application-controller-token-kfxct" + } + ] +} +` + +// Tests a real world example +func TestThreeWayDiffExample1(t *testing.T) { + var configUn, liveUn unstructured.Unstructured + // NOTE: it is intentional to unmarshal to Unstructured.Object instead of just Unstructured + // since it catches a case when we comparison fails due to subtle differences in types + // (e.g. float vs. int) + err := json.Unmarshal([]byte(demoConfig), &configUn.Object) + require.NoError(t, err) + err = json.Unmarshal([]byte(demoLive), &liveUn.Object) + require.NoError(t, err) + dr := diff(t, &configUn, &liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } +} + +// Test for ignoring aggregated cluster roles +func TestDiffOptionIgnoreAggregateRoles(t *testing.T) { + // Test case 1: Ignore option is true, the rules in the role should be ignored + { + configUn := unmarshalFile("testdata/aggr-clusterrole-config.json") + liveUn := unmarshalFile("testdata/aggr-clusterrole-live.json") + dr := diff(t, configUn, liveUn, IgnoreAggregatedRoles(true)) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } + // Test case 2: Ignore option is false, the aggregation should produce a diff + { + configUn := unmarshalFile("testdata/aggr-clusterrole-config.json") + liveUn := unmarshalFile("testdata/aggr-clusterrole-live.json") + dr := diff(t, configUn, liveUn, IgnoreAggregatedRoles(false)) + assert.True(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +func TestThreeWayDiffExample2(t *testing.T) { + configUn := unmarshalFile("testdata/elasticsearch-config.json") + liveUn := unmarshalFile("testdata/elasticsearch-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) +} + +// Tests a real world example +func TestThreeWayDiffExample3(t *testing.T) { + configUn := unmarshalFile("testdata/deployment-config.json") + liveUn := unmarshalFile("testdata/deployment-live.json") + + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } +} + +func TestThreeWayDiffExample4(t *testing.T) { + configUn := unmarshalFile("testdata/mutatingwebhookconfig-config.json") + liveUn := unmarshalFile("testdata/mutatingwebhookconfig-live.json") + + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + if ascii != "" { + t.Log(ascii) + } +} + +// TestThreeWayDiffExample2WithDifference is same as TestThreeWayDiffExample2 but with differences +func TestThreeWayDiffExample2WithDifference(t *testing.T) { + configUn := unmarshalFile("testdata/elasticsearch-config.json") + liveUn := unmarshalFile("testdata/elasticsearch-live.json") + labels := configUn.GetLabels() + // add a new label + labels["foo"] = "bar" + // modify a label + labels["chart"] = "elasticsearch-1.7.1" + // remove an existing label + delete(labels, "release") + configUn.SetLabels(labels) + + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.True(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err, ascii) + t.Log(ascii) + + // Check that we indicate missing/extra/changed correctly + showsMissing := 0 + showsExtra := 0 + showsChanged := 0 + for _, line := range strings.Split(ascii, "\n") { + if strings.HasPrefix(line, `> foo: bar`) { + showsMissing++ + } + if strings.HasPrefix(line, `< release: elasticsearch4`) { + showsExtra++ + } + if strings.HasPrefix(line, `> chart: elasticsearch-1.7.1`) { + showsChanged++ + } + if strings.HasPrefix(line, `< chart: elasticsearch-1.7.0`) { + showsChanged++ + } + } + assert.Equal(t, 1, showsMissing) + assert.Equal(t, 1, showsExtra) + assert.Equal(t, 2, showsChanged) +} + +func TestThreeWayDiffExplicitNamespace(t *testing.T) { + configUn := unmarshalFile("testdata/spinnaker-sa-config.json") + liveUn := unmarshalFile("testdata/spinnaker-sa-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) +} + +func TestDiffResourceWithInvalidField(t *testing.T) { + // Diff(...) should not silently discard invalid fields (fields that are not present in the underlying k8s resource). + + leftDep := `{ + "apiVersion": "v1", + "kind": "ConfigMap", + "metadata": { + "name": "invalid-cm" + }, + "invalidKey": "asdf" + }` + var leftUn unstructured.Unstructured + err := json.Unmarshal([]byte(leftDep), &leftUn.Object) + if err != nil { + panic(err) + } + + rightUn := leftUn.DeepCopy() + unstructured.RemoveNestedField(rightUn.Object, "invalidKey") + + diffRes := diff(t, &leftUn, rightUn, diffOptionsForTest()...) + assert.True(t, diffRes.Modified) + ascii, err := printDiff(diffRes) + require.NoError(t, err) + + assert.Contains(t, ascii, "invalidKey") + if ascii != "" { + t.Log(ascii) + } +} + +func TestRemoveNamespaceAnnotation(t *testing.T) { + obj := removeNamespaceAnnotation(&unstructured.Unstructured{Object: map[string]any{ + "metadata": map[string]any{ + "name": "test", + "namespace": "default", + }, + }}) + assert.Empty(t, obj.GetNamespace()) + + obj = removeNamespaceAnnotation(&unstructured.Unstructured{Object: map[string]any{ + "metadata": map[string]any{ + "name": "test", + "namespace": "default", + "annotations": make(map[string]any), + }, + }}) + assert.Empty(t, obj.GetNamespace()) + assert.Nil(t, obj.GetAnnotations()) + + obj = removeNamespaceAnnotation(&unstructured.Unstructured{Object: map[string]any{ + "metadata": map[string]any{ + "name": "test", + "namespace": "default", + "annotations": "wrong value", + }, + }}) + assert.Empty(t, obj.GetNamespace()) + val, _, _ := unstructured.NestedString(obj.Object, "metadata", "annotations") + assert.Equal(t, "wrong value", val) +} + +const customObjConfig = ` +apiVersion: foo.io/v1 +kind: Foo +metadata: + name: my-foo + namespace: kube-system +spec: + foo: bar +` + +const customObjLive = ` +apiVersion: foo.io/v1 +kind: Foo +metadata: + creationTimestamp: 2018-07-17 09:17:05 UTC + name: my-foo + resourceVersion: '10308211' + selfLink: "/apis/rbac.authorization.k8s.io/v1/clusterroles/argocd-manager-role" + uid: 2c3d5405-89a2-11e8-aff0-42010a8a0fc6 +spec: + foo: bar +` + +func TestIgnoreNamespaceForClusterScopedResources(t *testing.T) { + var configUn unstructured.Unstructured + var liveUn unstructured.Unstructured + err := yaml.Unmarshal([]byte(customObjLive), &liveUn) + require.NoError(t, err) + err = yaml.Unmarshal([]byte(customObjConfig), &configUn) + require.NoError(t, err) + dr := diff(t, &configUn, &liveUn, diffOptionsForTest()...) + assert.False(t, dr.Modified) +} + +const secretConfig = ` +apiVersion: v1 +kind: Secret +metadata: + name: my-secret +type: Opaque +stringData: + foo: bar + bar: "1234" +data: + baz: cXV4 +` + +const secretLive = ` +apiVersion: v1 +kind: Secret +metadata: + creationTimestamp: 2018-11-19T11:30:40Z + name: my-secret + namespace: argocd + resourceVersion: "25848035" + selfLink: /api/v1/namespaces/argocd/secrets/my-secret + uid: 8b4a2766-ebee-11e8-93c0-42010a8a0013 +type: Opaque +data: + foo: YmFy + bar: MTIzNA== + baz: cXV4 +` + +func TestSecretStringData(t *testing.T) { + var err error + var configUn unstructured.Unstructured + err = yaml.Unmarshal([]byte(secretConfig), &configUn) + require.NoError(t, err) + + var liveUn unstructured.Unstructured + err = yaml.Unmarshal([]byte(secretLive), &liveUn) + require.NoError(t, err) + + dr := diff(t, &configUn, &liveUn, diffOptionsForTest()...) + if !assert.False(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +// This is invalid because foo is a number, not a string +const secretInvalidConfig = ` +apiVersion: v1 +kind: Secret +metadata: + name: my-secret +type: Opaque +stringData: + foo: 1234 +` + +const secretInvalidLive = ` +apiVersion: v1 +kind: Secret +metadata: + creationTimestamp: 2018-11-19T11:30:40Z + name: my-secret + namespace: argocd + resourceVersion: "25848035" + selfLink: /api/v1/namespaces/argocd/secrets/my-secret + uid: 8b4a2766-ebee-11e8-93c0-42010a8a0013 +type: Opaque +data: + foo: MTIzNA== +` + +func TestInvalidSecretStringData(t *testing.T) { + var err error + var configUn unstructured.Unstructured + err = yaml.Unmarshal([]byte(secretInvalidConfig), &configUn) + require.NoError(t, err) + + var liveUn unstructured.Unstructured + err = yaml.Unmarshal([]byte(secretInvalidLive), &liveUn) + require.NoError(t, err) + + dr := diff(t, &configUn, nil, diffOptionsForTest()...) + assert.True(t, dr.Modified) +} + +func TestNullSecretData(t *testing.T) { + configUn := unmarshalFile("testdata/wordpress-config.json") + liveUn := unmarshalFile("testdata/wordpress-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +// TestRedactedSecretData tests we are able to perform diff on redacted secret data, which has +// invalid characters (*) for the the data byte array field. +func TestRedactedSecretData(t *testing.T) { + configUn := unmarshalFile("testdata/wordpress-config.json") + liveUn := unmarshalFile("testdata/wordpress-live.json") + configData := configUn.Object["data"].(map[string]any) + liveData := liveUn.Object["data"].(map[string]any) + configData["wordpress-password"] = "++++++++" + configData["smtp-password"] = "++++++++" + liveData["wordpress-password"] = "++++++++++++" + liveData["smtp-password"] = "++++++++++++" + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.True(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +func TestNullRoleRule(t *testing.T) { + configUn := unmarshalFile("testdata/grafana-clusterrole-config.json") + liveUn := unmarshalFile("testdata/grafana-clusterrole-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +func TestNullCreationTimestamp(t *testing.T) { + configUn := unmarshalFile("testdata/sealedsecret-config.json") + liveUn := unmarshalFile("testdata/sealedsecret-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +func TestUnsortedEndpoints(t *testing.T) { + configUn := unmarshalFile("testdata/endpoints-config.json") + liveUn := unmarshalFile("testdata/endpoints-live.json") + dr := diff(t, configUn, liveUn, diffOptionsForTest()...) + if !assert.False(t, dr.Modified) { + ascii, err := printDiff(dr) + require.NoError(t, err) + t.Log(ascii) + } +} + +func buildGVKParser(t *testing.T) *managedfields.GvkParser { + t.Helper() + document := &openapi_v2.Document{} + require.NoErrorf(t, proto.Unmarshal(testdata.OpenAPIV2Doc, document), "error unmarshaling openapi doc") + models, err := openapiproto.NewOpenAPIData(document) + require.NoErrorf(t, err, "error building openapi data: %s", err) + + gvkParser, err := managedfields.NewGVKParser(models, false) + require.NoErrorf(t, err, "error building gvkParser: %s", err) + return gvkParser +} + +func TestStructuredMergeDiff(t *testing.T) { + buildParams := func(live, config *unstructured.Unstructured) *SMDParams { + gvkParser := buildGVKParser(t) + manager := "argocd-controller" + return &SMDParams{ + config: config, + live: live, + gvkParser: gvkParser, + manager: manager, + } + } + + t.Run("will apply default values", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAML) + desiredState := StrToUnstructured(testdata.ServiceConfigYAML) + params := buildParams(liveState, desiredState) + + // when + result, err := structuredMergeDiff(params) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + predictedSVC := YamlToSvc(t, result.PredictedLive) + liveSVC := YamlToSvc(t, result.NormalizedLive) + require.NotNil(t, predictedSVC.Spec.InternalTrafficPolicy) + require.NotNil(t, liveSVC.Spec.InternalTrafficPolicy) + assert.Equal(t, "Cluster", string(*predictedSVC.Spec.InternalTrafficPolicy)) + assert.Equal(t, "Cluster", string(*liveSVC.Spec.InternalTrafficPolicy)) + assert.Empty(t, predictedSVC.Annotations[AnnotationLastAppliedConfig]) + assert.Empty(t, liveSVC.Annotations[AnnotationLastAppliedConfig]) + }) + t.Run("will remove entries in list", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAML) + desiredState := StrToUnstructured(testdata.ServiceConfigWith2Ports) + params := buildParams(liveState, desiredState) + + // when + result, err := structuredMergeDiff(params) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + svc := YamlToSvc(t, result.PredictedLive) + assert.Len(t, svc.Spec.Ports, 2) + }) + t.Run("will remove previously added fields not present in desired state", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.LiveServiceWithTypeYAML) + desiredState := StrToUnstructured(testdata.ServiceConfigYAML) + params := buildParams(liveState, desiredState) + + // when + result, err := structuredMergeDiff(params) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + svc := YamlToSvc(t, result.PredictedLive) + assert.Equal(t, corev1.ServiceTypeClusterIP, svc.Spec.Type) + }) + t.Run("will apply service with multiple ports", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAML) + desiredState := StrToUnstructured(testdata.ServiceConfigWithSamePortsYAML) + params := buildParams(liveState, desiredState) + + // when + result, err := structuredMergeDiff(params) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + svc := YamlToSvc(t, result.PredictedLive) + assert.Len(t, svc.Spec.Ports, 5) + }) + t.Run("will apply deployment defaults correctly", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.DeploymentLiveYAML) + desiredState := StrToUnstructured(testdata.DeploymentConfigYAML) + params := buildParams(liveState, desiredState) + + // when + result, err := structuredMergeDiff(params) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.False(t, result.Modified) + deploy := YamlToDeploy(t, result.PredictedLive) + assert.Len(t, deploy.Spec.Template.Spec.Containers, 1) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Requests.Cpu().String()) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Requests.Memory().String()) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Requests.Storage().String()) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Limits.Cpu().String()) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Limits.Memory().String()) + assert.Equal(t, "0", deploy.Spec.Template.Spec.Containers[0].Resources.Limits.Storage().String()) + require.NotNil(t, deploy.Spec.Strategy.RollingUpdate) + expectedMaxSurge := &intstr.IntOrString{ + Type: intstr.String, + StrVal: "25%", + } + assert.Equal(t, expectedMaxSurge, deploy.Spec.Strategy.RollingUpdate.MaxSurge) + assert.Equal(t, "ClusterFirst", string(deploy.Spec.Template.Spec.DNSPolicy)) + }) +} + +func TestServerSideDiff(t *testing.T) { + buildOpts := func(predictedLive string) []Option { + gvkParser := buildGVKParser(t) + manager := "argocd-controller" + dryRunner := mocks.NewServerSideDryRunner(t) + + dryRunner.On("Run", mock.Anything, mock.AnythingOfType("*unstructured.Unstructured"), manager). + Return(func(_ context.Context, _ *unstructured.Unstructured, _ string) (string, error) { + return predictedLive, nil + }) + opts := []Option{ + WithGVKParser(gvkParser), + WithManager(manager), + WithServerSideDryRunner(dryRunner), + } + + return opts + } + + buildOptsWithNormalizer := func(predictedLive string, normalizer Normalizer) []Option { + opts := buildOpts(predictedLive) + return append(opts, WithNormalizer(normalizer)) + } + + t.Run("will ignore modifications done by mutation webhook by default", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAMLSSD) + desiredState := StrToUnstructured(testdata.ServiceConfigYAMLSSD) + opts := buildOpts(testdata.ServicePredictedLiveJSONSSD) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + predictedSVC := YamlToSvc(t, result.PredictedLive) + liveSVC := YamlToSvc(t, result.NormalizedLive) + require.NotNil(t, predictedSVC.Spec.InternalTrafficPolicy) + require.NotNil(t, liveSVC.Spec.InternalTrafficPolicy) + assert.Equal(t, "Cluster", string(*predictedSVC.Spec.InternalTrafficPolicy)) + assert.Equal(t, "Cluster", string(*liveSVC.Spec.InternalTrafficPolicy)) + assert.Empty(t, predictedSVC.Annotations[AnnotationLastAppliedConfig]) + assert.Empty(t, liveSVC.Annotations[AnnotationLastAppliedConfig]) + assert.Empty(t, predictedSVC.Labels["event"]) + }) + + t.Run("will test removing some field with undoing changes done by webhook", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.Deployment2LiveYAML) + desiredState := StrToUnstructured(testdata.Deployment2ConfigYAML) + opts := buildOpts(testdata.Deployment2PredictedLiveJSONSSD) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + predictedDeploy := YamlToDeploy(t, result.PredictedLive) + liveDeploy := YamlToDeploy(t, result.NormalizedLive) + assert.Len(t, predictedDeploy.Spec.Template.Spec.Containers, 1) + assert.Len(t, liveDeploy.Spec.Template.Spec.Containers, 1) + assert.Equal(t, "500m", predictedDeploy.Spec.Template.Spec.Containers[0].Resources.Requests.Cpu().String()) + assert.Equal(t, "512Mi", predictedDeploy.Spec.Template.Spec.Containers[0].Resources.Requests.Memory().String()) + assert.Equal(t, "500m", liveDeploy.Spec.Template.Spec.Containers[0].Resources.Requests.Cpu().String()) + assert.Equal(t, "512Mi", liveDeploy.Spec.Template.Spec.Containers[0].Resources.Requests.Memory().String()) + }) + + t.Run("will include mutation webhook modifications", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAMLSSD) + desiredState := StrToUnstructured(testdata.ServiceConfigYAMLSSD) + opts := buildOpts(testdata.ServicePredictedLiveJSONSSD) + opts = append(opts, WithIgnoreMutationWebhook(false)) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + predictedSVC := YamlToSvc(t, result.PredictedLive) + liveSVC := YamlToSvc(t, result.NormalizedLive) + require.NotNil(t, predictedSVC.Spec.InternalTrafficPolicy) + require.NotNil(t, liveSVC.Spec.InternalTrafficPolicy) + assert.Equal(t, "Cluster", string(*predictedSVC.Spec.InternalTrafficPolicy)) + assert.Equal(t, "Cluster", string(*liveSVC.Spec.InternalTrafficPolicy)) + assert.Empty(t, predictedSVC.Annotations[AnnotationLastAppliedConfig]) + assert.Empty(t, liveSVC.Annotations[AnnotationLastAppliedConfig]) + assert.NotEmpty(t, predictedSVC.Labels["event"]) + }) + + t.Run("will include nested fields like ports and env", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.DeploymentNestedLiveYAMLSSD) + desiredState := StrToUnstructured(testdata.DeploymentNestedConfigYAMLSSD) + opts := buildOpts(testdata.DeploymentNestedPredictedLiveJSONSSD) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + + predictedDeploy := YamlToDeploy(t, result.PredictedLive) + liveDeploy := YamlToDeploy(t, result.NormalizedLive) + + // Check ports + assert.Len(t, predictedDeploy.Spec.Template.Spec.Containers[0].Ports, 2) + assert.Len(t, liveDeploy.Spec.Template.Spec.Containers[0].Ports, 1) + assert.Equal(t, int32(80), predictedDeploy.Spec.Template.Spec.Containers[0].Ports[0].ContainerPort) + assert.Equal(t, int32(443), predictedDeploy.Spec.Template.Spec.Containers[0].Ports[1].ContainerPort) + + // Check env + assert.Len(t, predictedDeploy.Spec.Template.Spec.Containers[0].Env, 2) + assert.Len(t, liveDeploy.Spec.Template.Spec.Containers[0].Env, 1) + assert.Equal(t, "ENV_VAR1", predictedDeploy.Spec.Template.Spec.Containers[0].Env[0].Name) + assert.Equal(t, "ENV_VAR2", predictedDeploy.Spec.Template.Spec.Containers[0].Env[1].Name) + }) + + t.Run("will add an extra container using kubectl apply and include mutation webhook", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.DeploymentApplyLiveYAMLSSD) + desiredState := StrToUnstructured(testdata.DeploymentApplyConfigYAMLSSD) + opts := buildOpts(testdata.DeploymentApplyPredictedLiveJSONSSD) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + + predictedDeploy := YamlToDeploy(t, result.PredictedLive) + liveDeploy := YamlToDeploy(t, result.NormalizedLive) + + // Check ports are shown in diff and ensure mutation webhook is not shown + assert.Len(t, predictedDeploy.Spec.Template.Spec.Containers[0].Ports, 2) + assert.Len(t, liveDeploy.Spec.Template.Spec.Containers[0].Ports, 1) + assert.Equal(t, int32(80), predictedDeploy.Spec.Template.Spec.Containers[0].Ports[0].ContainerPort) + assert.Equal(t, int32(40), predictedDeploy.Spec.Template.Spec.Containers[0].Ports[1].ContainerPort) + assert.Empty(t, predictedDeploy.Annotations[AnnotationLastAppliedConfig]) + assert.Empty(t, liveDeploy.Annotations[AnnotationLastAppliedConfig]) + }) + + t.Run("will reflect deletion of labels in predicted live", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveLabelYAMLSSD) + desiredState := StrToUnstructured(testdata.ServiceConfigNoLabelYAMLSSD) + opts := buildOpts(testdata.ServicePredictedLiveNoLabelJSONSSD) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + assert.True(t, result.Modified) + + predictedSvc := YamlToSvc(t, result.PredictedLive) + liveSvc := YamlToSvc(t, result.NormalizedLive) + + // Ensure that the deleted label is not present in predicted and exists in live + _, predictedLabelExists := predictedSvc.Labels["delete-me"] + _, liveLabelExists := liveSvc.Labels["delete-me"] + assert.False(t, predictedLabelExists) + assert.True(t, liveLabelExists) + }) + + t.Run("will respect ignoreDifferences when full normalization is not skipped", func(t *testing.T) { + // given + t.Parallel() + liveState := StrToUnstructured(testdata.ServiceLiveYAMLSSD) + desiredState := StrToUnstructured(testdata.ServiceConfigYAMLSSD) + + // Normalizer that ignores sessionAffinity (auto-assigned field that's commonly ignored) + normalizer := &testIgnoreDifferencesNormalizer{ + fieldsToRemove: [][]string{ + {"spec", "sessionAffinity"}, + }, + } + + opts := buildOptsWithNormalizer(testdata.ServicePredictedLiveJSONSSD, normalizer) + + // when + result, err := serverSideDiff(desiredState, liveState, opts...) + + // then + require.NoError(t, err) + assert.NotNil(t, result) + + // Should show diff for other fields but not the ignored sessionAffinity + assert.True(t, result.Modified, "Should show diff for non-ignored fields") + + // Convert results to strings for verification + predictedLiveStr := string(result.PredictedLive) + normalizedLiveStr := string(result.NormalizedLive) + + // Ports should appear in diff (not ignored) + assert.Contains(t, predictedLiveStr, "port", "Port differences should be visible") + + // The ignored sessionAffinity should NOT appear in final result + assert.NotContains(t, predictedLiveStr, "sessionAffinity", "sessionAffinity should be removed by normalization") + assert.NotContains(t, normalizedLiveStr, "sessionAffinity", "sessionAffinity should be removed by normalization") + + // Other fields should still be visible (not ignored) + assert.Contains(t, predictedLiveStr, "selector", "Other fields should remain visible") + }) +} + +// testIgnoreDifferencesNormalizer implements a simple normalizer that removes specified fields +type testIgnoreDifferencesNormalizer struct { + fieldsToRemove [][]string +} + +func (n *testIgnoreDifferencesNormalizer) Normalize(un *unstructured.Unstructured) error { + if un == nil { + return nil + } + for _, fieldPath := range n.fieldsToRemove { + unstructured.RemoveNestedField(un.Object, fieldPath...) + } + return nil +} + +func createSecret(data map[string]string) *unstructured.Unstructured { + secret := corev1.Secret{TypeMeta: metav1.TypeMeta{Kind: "Secret"}} + if data != nil { + secret.Data = make(map[string][]byte) + for k, v := range data { + secret.Data[k] = []byte(v) + } + } + + return mustToUnstructured(&secret) +} + +func secretData(obj *unstructured.Unstructured) map[string]any { + data, _, _ := unstructured.NestedMap(obj.Object, "data") + return data +} + +var ( + replacement1 = strings.Repeat("+", 8) + replacement2 = strings.Repeat("+", 12) + replacement3 = strings.Repeat("+", 16) +) + +func TestHideSecretDataSameKeysDifferentValues(t *testing.T) { + target, live, err := HideSecretData( + createSecret(map[string]string{"key1": "test", "key2": "test"}), + createSecret(map[string]string{"key1": "test-1", "key2": "test-1"}), + nil, + ) + require.NoError(t, err) + + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement1}, secretData(target)) + assert.Equal(t, map[string]any{"key1": replacement2, "key2": replacement2}, secretData(live)) +} + +func TestHideSecretDataSameKeysSameValues(t *testing.T) { + target, live, err := HideSecretData( + createSecret(map[string]string{"key1": "test", "key2": "test"}), + createSecret(map[string]string{"key1": "test", "key2": "test"}), + nil, + ) + require.NoError(t, err) + + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement1}, secretData(target)) + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement1}, secretData(live)) +} + +func TestHideSecretDataDifferentKeysDifferentValues(t *testing.T) { + target, live, err := HideSecretData( + createSecret(map[string]string{"key1": "test", "key2": "test"}), + createSecret(map[string]string{"key2": "test-1", "key3": "test-1"}), + nil, + ) + require.NoError(t, err) + + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement1}, secretData(target)) + assert.Equal(t, map[string]any{"key2": replacement2, "key3": replacement1}, secretData(live)) +} + +func TestHideStringDataInInvalidSecret(t *testing.T) { + liveUn := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + }, + "type": "Opaque", + "data": map[string]any{ + "key1": "a2V5MQ==", + "key2": "a2V5MQ==", + }, + }, + } + targetUn := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + }, + "type": "Opaque", + "data": map[string]any{ + "key1": "a2V5MQ==", + "key2": "a2V5Mg==", + "key3": false, + }, + "stringData": map[string]any{ + "key4": "key4", + "key5": 5, + }, + }, + } + + liveUn = remarshal(liveUn, applyOptions(diffOptionsForTest())) + targetUn = remarshal(targetUn, applyOptions(diffOptionsForTest())) + + target, live, err := HideSecretData(targetUn, liveUn, nil) + require.NoError(t, err) + + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement2}, secretData(live)) + assert.Equal(t, map[string]any{"key1": replacement1, "key2": replacement1, "key3": replacement1, "key4": replacement1, "key5": replacement1}, secretData(target)) +} + +// stringData in secrets should be normalized even if it is invalid +func TestNormalizeSecret(t *testing.T) { + tests := []struct { + testname string + data map[string]any + stringData map[string]any + }{ + { + testname: "Valid secret", + data: map[string]any{ + "key1": "key1", + }, + stringData: map[string]any{ + "key2": "a2V5Mg==", + }, + }, + { + testname: "Invalid secret", + data: map[string]any{ + "key1": "key1", + "key2": 2, + }, + stringData: map[string]any{ + "key3": "key3", + "key4": nil, + }, + }, + { + testname: "Invalid secret with stringData only", + data: nil, + stringData: map[string]any{ + "key3": "key3", + "key4": true, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.testname, func(t *testing.T) { + un := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + }, + "type": "Opaque", + "data": tt.data, + "stringData": tt.stringData, + }, + } + un = remarshal(un, applyOptions(diffOptionsForTest())) + + NormalizeSecret(un) + + _, found, _ := unstructured.NestedMap(un.Object, "stringData") + assert.False(t, found) + + data, found, _ := unstructured.NestedMap(un.Object, "data") + assert.True(t, found) + + // check all secret keys are found under data in normalized secret + for _, obj := range []map[string]any{tt.data, tt.stringData} { + if obj == nil { + continue + } + for k := range obj { + _, ok := data[k] + assert.True(t, ok) + } + } + }) + } +} + +func TestHideSecretAnnotations(t *testing.T) { + tests := []struct { + name string + hideAnnots map[string]bool + annots map[string]any + expectedAnnots map[string]any + targetNil bool + }{ + { + name: "no hidden annotations", + hideAnnots: nil, + annots: map[string]any{"token/value": "secret", "key": "secret-key", "app": "test"}, + expectedAnnots: map[string]any{"token/value": "secret", "key": "secret-key", "app": "test"}, + }, + { + name: "hide annotations", + hideAnnots: map[string]bool{"token/value": true, "key": true}, + annots: map[string]any{"token/value": "secret", "key": "secret-key", "app": "test"}, + expectedAnnots: map[string]any{"token/value": replacement1, "key": replacement1, "app": "test"}, + }, + { + name: "hide annotations in last-applied-config", + hideAnnots: map[string]bool{"token/value": true, "key": true}, + annots: map[string]any{ + "token/value": "secret", + "app": "test", + "kubectl.kubernetes.io/last-applied-configuration": `{"apiVersion":"v1","kind":"Secret","metadata":{"annotations":{"app":"test","token/value":"secret","key":"secret-key"},"labels":{"app.kubernetes.io/instance":"test"},"name":"my-secret","namespace":"default"},"type":"Opaque"}`, + }, + expectedAnnots: map[string]any{ + "token/value": replacement1, + "app": "test", + "kubectl.kubernetes.io/last-applied-configuration": `{"apiVersion":"v1","kind":"Secret","metadata":{"annotations":{"app":"test","key":"++++++++","token/value":"++++++++"},"labels":{"app.kubernetes.io/instance":"test"},"name":"my-secret","namespace":"default"},"type":"Opaque"}`, + }, + targetNil: true, + }, + { + name: "special case: hide last-applied-config annotation", + hideAnnots: map[string]bool{"kubectl.kubernetes.io/last-applied-configuration": true}, + annots: map[string]any{ + "token/value": replacement1, + "app": "test", + "kubectl.kubernetes.io/last-applied-configuration": `{"apiVersion":"v1","kind":"Secret","metadata":{"annotations":{"app":"test","token/value":"secret","key":"secret-key"},"labels":{"app.kubernetes.io/instance":"test"},"name":"my-secret","namespace":"default"},"type":"Opaque"}`, + }, + expectedAnnots: map[string]any{ + "app": "test", + "kubectl.kubernetes.io/last-applied-configuration": replacement1, + }, + targetNil: true, + }, + { + name: "hide annotations for malformed annotations", + hideAnnots: map[string]bool{"token/value": true, "key": true}, + annots: map[string]any{"token/value": 0, "key": "secret", "app": true}, + expectedAnnots: map[string]any{"token/value": replacement1, "key": replacement1, "app": true}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + unSecret := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + "annotations": tt.annots, + }, + "type": "Opaque", + }, + } + + liveUn := remarshal(unSecret, applyOptions(diffOptionsForTest())) + targetUn := remarshal(unSecret, applyOptions(diffOptionsForTest())) + + if tt.targetNil { + targetUn = nil + } + + target, live, err := HideSecretData(targetUn, liveUn, tt.hideAnnots) + require.NoError(t, err) + + // verify configured annotations are hidden + for _, obj := range []*unstructured.Unstructured{target, live} { + if obj != nil { + annots, _, _ := unstructured.NestedMap(obj.Object, "metadata", "annotations") + for ek, ev := range tt.expectedAnnots { + v, found := annots[ek] + assert.True(t, found) + assert.Equal(t, ev, v) + } + } + } + }) + } +} + +func TestHideSecretAnnotationsPreserveDifference(t *testing.T) { + hideAnnots := map[string]bool{"token/value": true} + + liveUn := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + "annotations": map[string]any{"token/value": "secret", "app": "test"}, + }, + "type": "Opaque", + }, + } + targetUn := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": map[string]any{ + "name": "test-secret", + "annotations": map[string]any{"token/value": "new-secret", "app": "test"}, + }, + "type": "Opaque", + }, + } + + liveUn = remarshal(liveUn, applyOptions(diffOptionsForTest())) + targetUn = remarshal(targetUn, applyOptions(diffOptionsForTest())) + + target, live, err := HideSecretData(targetUn, liveUn, hideAnnots) + require.NoError(t, err) + + liveAnnots := live.GetAnnotations() + v, found := liveAnnots["token/value"] + assert.True(t, found) + assert.Equal(t, replacement2, v) + + targetAnnots := target.GetAnnotations() + v, found = targetAnnots["token/value"] + assert.True(t, found) + assert.Equal(t, replacement1, v) +} + +func getTargetSecretJsonBytes() []byte { + return []byte(` +{ + "apiVersion": "v1", + "kind": "Secret", + "type": "kubernetes.io/service-account-token", + "metadata": { + "annotations": { + "kubernetes.io/service-account.name": "default" + }, + "labels": { + "app.kubernetes.io/instance": "empty-secret" + }, + "name": "an-empty-secret", + "namespace": "default" + }, + "data": {} +}`) +} + +func getLiveSecretJsonBytes() []byte { + return []byte(` +{ + "kind": "Secret", + "apiVersion": "v1", + "type": "kubernetes.io/service-account-token", + "metadata": { + "annotations": { + "kubernetes.io/service-account.name": "default", + "kubernetes.io/service-account.uid": "78688180-d432-4ee8-939d-382b015a6b13" + }, + "creationTimestamp": "2021-10-27T19:09:22Z", + "labels": { + "app.kubernetes.io/instance": "empty-secret" + }, + "name": "an-empty-secret", + "namespace": "default", + "resourceVersion": "2329692", + "uid": "2e98590d-a699-4281-89d5-aa94dfc1d7d7" + }, + "data": { + "namespace": "ZGVmYXVsdA==", + "token": "ZGVmYXVsdAcb==" + } +}`) +} + +func bytesToUnstructured(t *testing.T, jsonBytes []byte) *unstructured.Unstructured { + t.Helper() + var jsonMap map[string]any + require.NoError(t, json.Unmarshal(jsonBytes, &jsonMap)) + return &unstructured.Unstructured{ + Object: jsonMap, + } +} + +func TestHideSecretDataHandleEmptySecret(t *testing.T) { + // given + targetSecret := bytesToUnstructured(t, getTargetSecretJsonBytes()) + liveSecret := bytesToUnstructured(t, getLiveSecretJsonBytes()) + + // when + target, live, err := HideSecretData(targetSecret, liveSecret, nil) + + // then + require.NoError(t, err) + assert.NotNil(t, target) + assert.NotNil(t, live) + assert.Nil(t, target.Object["data"]) + assert.Equal(t, map[string]any{"namespace": "++++++++", "token": "++++++++"}, secretData(live)) +} + +func TestHideSecretDataLastAppliedConfig(t *testing.T) { + lastAppliedSecret := createSecret(map[string]string{"key1": "test1"}) + targetSecret := createSecret(map[string]string{"key1": "test2"}) + liveSecret := createSecret(map[string]string{"key1": "test3"}) + lastAppliedStr, err := json.Marshal(lastAppliedSecret) + require.NoError(t, err) + liveSecret.SetAnnotations(map[string]string{corev1.LastAppliedConfigAnnotation: string(lastAppliedStr)}) + + target, live, err := HideSecretData(targetSecret, liveSecret, nil) + require.NoError(t, err) + err = json.Unmarshal([]byte(live.GetAnnotations()[corev1.LastAppliedConfigAnnotation]), &lastAppliedSecret) + require.NoError(t, err) + + assert.Equal(t, map[string]any{"key1": replacement1}, secretData(target)) + assert.Equal(t, map[string]any{"key1": replacement2}, secretData(live)) + assert.Equal(t, map[string]any{"key1": replacement3}, secretData(lastAppliedSecret)) +} + +func TestRemarshal(t *testing.T) { + manifest := []byte(` +apiVersion: v1 +kind: ServiceAccount +imagePullSecrets: [] +metadata: + name: my-sa +`) + var un unstructured.Unstructured + require.NoError(t, yaml.Unmarshal(manifest, &un)) + newUn := remarshal(&un, applyOptions(diffOptionsForTest())) + _, ok := newUn.Object["imagePullSecrets"] + assert.False(t, ok) + metadata := newUn.Object["metadata"].(map[string]any) + _, ok = metadata["creationTimestamp"] + assert.False(t, ok) +} + +func TestRemarshalResources(t *testing.T) { + getRequests := func(un *unstructured.Unstructured) map[string]any { + return un.Object["spec"].(map[string]any)["containers"].([]any)[0].(map[string]any)["resources"].(map[string]any)["requests"].(map[string]any) + } + + setRequests := func(un *unstructured.Unstructured, requests map[string]any) { + un.Object["spec"].(map[string]any)["containers"].([]any)[0].(map[string]any)["resources"].(map[string]any)["requests"] = requests + } + + manifest := []byte(` +apiVersion: v1 +kind: Pod +metadata: + name: my-pod +spec: + containers: + - image: nginx:1.7.9 + name: nginx + resources: + requests: + cpu: 0.2 +`) + un := unstructured.Unstructured{} + require.NoError(t, yaml.Unmarshal(manifest, &un)) + + testCases := []struct { + name string + cpu any + expectedCPU any + }{ + {"from float", 0.2, "200m"}, + {"from float64", float64(0.2), "200m"}, + {"from string", "0.2", "200m"}, + {"from invalid", "invalid", "invalid"}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + setRequests(&un, map[string]any{"cpu": tc.cpu}) + newUn := remarshal(&un, applyOptions(diffOptionsForTest())) + requestsAfter := getRequests(newUn) + assert.Equal(t, tc.expectedCPU, requestsAfter["cpu"]) + }) + } +} + +func ExampleDiff() { + expectedResource := unstructured.Unstructured{} + if err := yaml.Unmarshal([]byte(` +apiVersion: v1 +kind: Pod +metadata: + name: my-pod +spec: + containers: + - image: nginx:1.7.9 + name: nginx + resources: + requests: + cpu: 0.2 +`), &expectedResource); err != nil { + panic(err) + } + + liveResource := unstructured.Unstructured{} + if err := yaml.Unmarshal([]byte(` +apiVersion: v1 +kind: Pod +metadata: + name: my-pod-123 + creationTimestamp: "2020-03-30T21:34:59Z" + labels: + pod-template-hash: 84bf9649fd + name: argo-cd-cli-84bf9649fd-tm59q + resourceVersion: "233081332" + uid: 9a5ae31a-eed2-4f82-81fe-833799c54f99 +spec: + containers: + - image: nginx:1.7.9 + name: nginx + resources: + requests: + cpu: 0.1 +`), &liveResource); err != nil { + panic(err) + } + diff, err := Diff(&expectedResource, &liveResource, diffOptionsForTest()...) + if err != nil { + panic(err) + } + if diff.Modified { + fmt.Println("Resources are different") + } +} + +func diffOptionsForTest() []Option { + return []Option{ + WithLogr(textlogger.NewLogger(textlogger.NewConfig())), + IgnoreAggregatedRoles(false), + } +} + +func YamlToSvc(t *testing.T, y []byte) *corev1.Service { + t.Helper() + svc := corev1.Service{} + require.NoErrorf(t, yaml.Unmarshal(y, &svc), "error unmarshaling service bytes") + return &svc +} + +func YamlToDeploy(t *testing.T, y []byte) *appsv1.Deployment { + t.Helper() + deploy := appsv1.Deployment{} + require.NoErrorf(t, yaml.Unmarshal(y, &deploy), "error unmarshaling deployment bytes") + return &deploy +} + +func StrToUnstructured(yamlStr string) *unstructured.Unstructured { + obj := make(map[string]any) + err := yaml.Unmarshal([]byte(yamlStr), &obj) + if err != nil { + panic(err) + } + return &unstructured.Unstructured{Object: obj} +} + +func TestDiffWithIgnoreDifferences(t *testing.T) { + t.Run("TwoWayDiff will respect ignoreDifferences for comparison but not output normalization", func(t *testing.T) { + // given + t.Parallel() + + // Create a simple service with sessionAffinity that should be ignored + liveService := StrToUnstructured(` +apiVersion: v1 +kind: Service +metadata: + name: my-service +spec: + selector: + app: my-app + ports: + - port: 80 + sessionAffinity: None + type: ClusterIP +`) + + desiredService := StrToUnstructured(` +apiVersion: v1 +kind: Service +metadata: + name: my-service +spec: + selector: + app: my-app + ports: + - port: 80 + sessionAffinity: ClientIP + type: ClusterIP +`) + + // Normalizer that ignores sessionAffinity + normalizer := &testIgnoreDifferencesNormalizer{ + fieldsToRemove: [][]string{ + {"spec", "sessionAffinity"}, + }, + } + + opts := []Option{ + WithNormalizer(normalizer), + WithLogr(textlogger.NewLogger(textlogger.NewConfig())), + } + + // when + result, err := Diff(desiredService, liveService, opts...) + require.NoError(t, err) + + // then + assert.NotNil(t, result) + + // Since sessionAffinity is ignored in input normalization, there should be no modification + assert.False(t, result.Modified, "Should not show diff for ignored fields") + + predictedLiveStr := string(result.PredictedLive) + normalizedLiveStr := string(result.NormalizedLive) + + // NOTE: Unlike server-side diff, TwoWayDiff/ThreeWayDiff don't normalize outputs + // So sessionAffinity WILL still appear in the output bytes, but Modified should be false + // because input normalization removed the differences during comparison + assert.Contains(t, predictedLiveStr, "sessionAffinity", "sessionAffinity should still appear in output (no output normalization)") + assert.Contains(t, normalizedLiveStr, "sessionAffinity", "sessionAffinity should still appear in output (no output normalization)") + }) + + t.Run("ThreeWayDiff will respect ignoreDifferences for comparison but not output normalization", func(t *testing.T) { + // given + t.Parallel() + + // Create config and live with sessionAffinity differences that should be ignored + configService := StrToUnstructured(` +apiVersion: v1 +kind: Service +metadata: + name: my-service +spec: + selector: + app: my-app + ports: + - port: 80 + sessionAffinity: ClientIP + type: ClusterIP +`) + + liveService := StrToUnstructured(` +apiVersion: v1 +kind: Service +metadata: + name: my-service + annotations: + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"v1","kind":"Service","metadata":{"name":"my-service"},"spec":{"selector":{"app":"my-app"},"ports":[{"port":80}],"sessionAffinity":"None","type":"ClusterIP"}} +spec: + selector: + app: my-app + ports: + - port: 80 + sessionAffinity: None + type: ClusterIP +`) + + // Normalizer that ignores sessionAffinity + normalizer := &testIgnoreDifferencesNormalizer{ + fieldsToRemove: [][]string{ + {"spec", "sessionAffinity"}, + }, + } + + opts := []Option{ + WithNormalizer(normalizer), + WithLogr(textlogger.NewLogger(textlogger.NewConfig())), + } + + // when + result, err := Diff(configService, liveService, opts...) + require.NoError(t, err) + + // then + assert.NotNil(t, result) + + // Since sessionAffinity is ignored in input normalization, there should be no modification + assert.False(t, result.Modified, "Should not show diff for ignored fields") + + predictedLiveStr := string(result.PredictedLive) + normalizedLiveStr := string(result.NormalizedLive) + + // NOTE: Unlike server-side diff, TwoWayDiff/ThreeWayDiff don't normalize outputs + // So sessionAffinity WILL still appear in the output bytes, but Modified should be false + // because input normalization removed the differences during comparison + assert.Contains(t, predictedLiveStr, "sessionAffinity", "sessionAffinity should still appear in output (no output normalization)") + assert.Contains(t, normalizedLiveStr, "sessionAffinity", "sessionAffinity should still appear in output (no output normalization)") + }) +} diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/README b/gitops-engine/pkg/diff/internal/fieldmanager/README new file mode 100644 index 0000000000000..5efb7278b6893 --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/README @@ -0,0 +1,2 @@ +Please check the doc.go file for more details about +how to use and maintain the code in this package. diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_fields.go b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_fields.go new file mode 100644 index 0000000000000..cc81456b9c4bd --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_fields.go @@ -0,0 +1,47 @@ +/* +Copyright 2018 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 fieldmanager + +import ( + "bytes" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "sigs.k8s.io/structured-merge-diff/v6/fieldpath" +) + +// EmptyFields represents a set with no paths +// It looks like metav1.Fields{Raw: []byte("{}")} +var EmptyFields = func() metav1.FieldsV1 { + f, err := SetToFields(*fieldpath.NewSet()) + if err != nil { + panic("should never happen") + } + return f +}() + +// FieldsToSet creates a set paths from an input trie of fields +func FieldsToSet(f metav1.FieldsV1) (s fieldpath.Set, err error) { + err = s.FromJSON(bytes.NewReader(f.Raw)) + return s, err +} + +// SetToFields creates a trie of fields from an input set of paths +func SetToFields(s fieldpath.Set) (f metav1.FieldsV1, err error) { + f.Raw, err = s.ToJSON() + return f, err +} diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_managedfields.go b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_managedfields.go new file mode 100644 index 0000000000000..44d97b5b7a619 --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_managedfields.go @@ -0,0 +1,248 @@ +/* +Copyright 2018 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 fieldmanager + +import ( + "encoding/json" + "fmt" + "sort" + + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/structured-merge-diff/v6/fieldpath" +) + +// ManagedInterface groups a fieldpath.ManagedFields together with the timestamps associated with each operation. +type ManagedInterface interface { + // Fields gets the fieldpath.ManagedFields. + Fields() fieldpath.ManagedFields + + // Times gets the timestamps associated with each operation. + Times() map[string]*metav1.Time +} + +type managedStruct struct { + fields fieldpath.ManagedFields + times map[string]*metav1.Time +} + +var _ ManagedInterface = &managedStruct{} + +// Fields implements ManagedInterface. +func (m *managedStruct) Fields() fieldpath.ManagedFields { + return m.fields +} + +// Times implements ManagedInterface. +func (m *managedStruct) Times() map[string]*metav1.Time { + return m.times +} + +// NewEmptyManaged creates an empty ManagedInterface. +func NewEmptyManaged() ManagedInterface { + return NewManaged(fieldpath.ManagedFields{}, map[string]*metav1.Time{}) +} + +// NewManaged creates a ManagedInterface from a fieldpath.ManagedFields and the timestamps associated with each operation. +func NewManaged(f fieldpath.ManagedFields, t map[string]*metav1.Time) ManagedInterface { + return &managedStruct{ + fields: f, + times: t, + } +} + +// RemoveObjectManagedFields removes the ManagedFields from the object +// before we merge so that it doesn't appear in the ManagedFields +// recursively. +func RemoveObjectManagedFields(obj runtime.Object) { + accessor, err := meta.Accessor(obj) + if err != nil { + panic(fmt.Sprintf("couldn't get accessor: %v", err)) + } + accessor.SetManagedFields(nil) +} + +// EncodeObjectManagedFields converts and stores the fieldpathManagedFields into the objects ManagedFields +func EncodeObjectManagedFields(obj runtime.Object, managed ManagedInterface) error { + accessor, err := meta.Accessor(obj) + if err != nil { + panic(fmt.Sprintf("couldn't get accessor: %v", err)) + } + + encodedManagedFields, err := encodeManagedFields(managed) + if err != nil { + return fmt.Errorf("failed to convert back managed fields to API: %v", err) + } + accessor.SetManagedFields(encodedManagedFields) + + return nil +} + +// DecodeManagedFields converts ManagedFields from the wire format (api format) +// to the format used by sigs.k8s.io/structured-merge-diff +func DecodeManagedFields(encodedManagedFields []metav1.ManagedFieldsEntry) (ManagedInterface, error) { + managed := managedStruct{} + managed.fields = make(fieldpath.ManagedFields, len(encodedManagedFields)) + managed.times = make(map[string]*metav1.Time, len(encodedManagedFields)) + + for i, encodedVersionedSet := range encodedManagedFields { + switch encodedVersionedSet.Operation { + case metav1.ManagedFieldsOperationApply, metav1.ManagedFieldsOperationUpdate: + default: + return nil, fmt.Errorf("operation must be `Apply` or `Update`") + } + if len(encodedVersionedSet.APIVersion) < 1 { + return nil, fmt.Errorf("apiVersion must not be empty") + } + switch encodedVersionedSet.FieldsType { + case "FieldsV1": + // Valid case. + case "": + return nil, fmt.Errorf("missing fieldsType in managed fields entry %d", i) + default: + return nil, fmt.Errorf("invalid fieldsType %q in managed fields entry %d", encodedVersionedSet.FieldsType, i) + } + manager, err := BuildManagerIdentifier(&encodedVersionedSet) + if err != nil { + return nil, fmt.Errorf("error decoding manager from %v: %v", encodedVersionedSet, err) + } + managed.fields[manager], err = decodeVersionedSet(&encodedVersionedSet) + if err != nil { + return nil, fmt.Errorf("error decoding versioned set from %v: %v", encodedVersionedSet, err) + } + managed.times[manager] = encodedVersionedSet.Time + } + return &managed, nil +} + +// BuildManagerIdentifier creates a manager identifier string from a ManagedFieldsEntry +func BuildManagerIdentifier(encodedManager *metav1.ManagedFieldsEntry) (manager string, err error) { + encodedManagerCopy := *encodedManager + + // Never include fields type in the manager identifier + encodedManagerCopy.FieldsType = "" + + // Never include the fields in the manager identifier + encodedManagerCopy.FieldsV1 = nil + + // Never include the time in the manager identifier + encodedManagerCopy.Time = nil + + // For appliers, don't include the APIVersion in the manager identifier, + // so it will always have the same manager identifier each time it applied. + if encodedManager.Operation == metav1.ManagedFieldsOperationApply { + encodedManagerCopy.APIVersion = "" + } + + // Use the remaining fields to build the manager identifier + b, err := json.Marshal(&encodedManagerCopy) + if err != nil { + return "", fmt.Errorf("error marshalling manager identifier: %v", err) + } + + return string(b), nil +} + +func decodeVersionedSet(encodedVersionedSet *metav1.ManagedFieldsEntry) (versionedSet fieldpath.VersionedSet, err error) { + fields := EmptyFields + if encodedVersionedSet.FieldsV1 != nil { + fields = *encodedVersionedSet.FieldsV1 + } + set, err := FieldsToSet(fields) + if err != nil { + return nil, fmt.Errorf("error decoding set: %v", err) + } + return fieldpath.NewVersionedSet(&set, fieldpath.APIVersion(encodedVersionedSet.APIVersion), encodedVersionedSet.Operation == metav1.ManagedFieldsOperationApply), nil +} + +// encodeManagedFields converts ManagedFields from the format used by +// sigs.k8s.io/structured-merge-diff to the wire format (api format) +func encodeManagedFields(managed ManagedInterface) (encodedManagedFields []metav1.ManagedFieldsEntry, err error) { + if len(managed.Fields()) == 0 { + return nil, nil + } + encodedManagedFields = []metav1.ManagedFieldsEntry{} + for manager := range managed.Fields() { + versionedSet := managed.Fields()[manager] + v, err := encodeManagerVersionedSet(manager, versionedSet) + if err != nil { + return nil, fmt.Errorf("error encoding versioned set for %v: %v", manager, err) + } + if t, ok := managed.Times()[manager]; ok { + v.Time = t + } + encodedManagedFields = append(encodedManagedFields, *v) + } + return sortEncodedManagedFields(encodedManagedFields) +} + +func sortEncodedManagedFields(encodedManagedFields []metav1.ManagedFieldsEntry) (sortedManagedFields []metav1.ManagedFieldsEntry, err error) { + sort.Slice(encodedManagedFields, func(i, j int) bool { + p, q := encodedManagedFields[i], encodedManagedFields[j] + + if p.Operation != q.Operation { + return p.Operation < q.Operation + } + + pSeconds, qSeconds := int64(0), int64(0) + if p.Time != nil { + pSeconds = p.Time.Unix() + } + if q.Time != nil { + qSeconds = q.Time.Unix() + } + if pSeconds != qSeconds { + return pSeconds < qSeconds + } + + if p.Manager != q.Manager { + return p.Manager < q.Manager + } + + if p.APIVersion != q.APIVersion { + return p.APIVersion < q.APIVersion + } + return p.Subresource < q.Subresource + }) + + return encodedManagedFields, nil +} + +func encodeManagerVersionedSet(manager string, versionedSet fieldpath.VersionedSet) (encodedVersionedSet *metav1.ManagedFieldsEntry, err error) { + encodedVersionedSet = &metav1.ManagedFieldsEntry{} + + // Get as many fields as we can from the manager identifier + err = json.Unmarshal([]byte(manager), encodedVersionedSet) + if err != nil { + return nil, fmt.Errorf("error unmarshalling manager identifier %v: %v", manager, err) + } + + // Get the APIVersion, Operation, and Fields from the VersionedSet + encodedVersionedSet.APIVersion = string(versionedSet.APIVersion()) + if versionedSet.Applied() { + encodedVersionedSet.Operation = metav1.ManagedFieldsOperationApply + } + encodedVersionedSet.FieldsType = "FieldsV1" + fields, err := SetToFields(*versionedSet.Set()) + if err != nil { + return nil, fmt.Errorf("error encoding set: %v", err) + } + encodedVersionedSet.FieldsV1 = &fields + + return encodedVersionedSet, nil +} diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_typeconverter.go b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_typeconverter.go new file mode 100644 index 0000000000000..7801d5dc0fdbf --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_typeconverter.go @@ -0,0 +1,130 @@ +/* +Copyright 2018 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 fieldmanager + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/kube-openapi/pkg/util/proto" + "sigs.k8s.io/structured-merge-diff/v6/typed" + "sigs.k8s.io/structured-merge-diff/v6/value" +) + +// TypeConverter allows you to convert from runtime.Object to +// typed.TypedValue and the other way around. +type TypeConverter interface { + ObjectToTyped(runtime.Object) (*typed.TypedValue, error) + TypedToObject(*typed.TypedValue) (runtime.Object, error) +} + +// DeducedTypeConverter is a TypeConverter for CRDs that don't have a +// schema. It does implement the same interface though (and create the +// same types of objects), so that everything can still work the same. +// CRDs are merged with all their fields being "atomic" (lists +// included). +// +// Note that this is not going to be sufficient for converting to/from +// CRDs that have a schema defined (we don't support that schema yet). +// TODO(jennybuckley): Use the schema provided by a CRD if it exists. +type DeducedTypeConverter struct{} + +var _ TypeConverter = DeducedTypeConverter{} + +// ObjectToTyped converts an object into a TypedValue with a "deduced type". +func (DeducedTypeConverter) ObjectToTyped(obj runtime.Object) (*typed.TypedValue, error) { + switch o := obj.(type) { + case *unstructured.Unstructured: + return typed.DeducedParseableType.FromUnstructured(o.UnstructuredContent()) + default: + return typed.DeducedParseableType.FromStructured(obj) + } +} + +// TypedToObject transforms the typed value into a runtime.Object. That +// is not specific to deduced type. +func (DeducedTypeConverter) TypedToObject(value *typed.TypedValue) (runtime.Object, error) { + return valueToObject(value.AsValue()) +} + +type typeConverter struct { + parser *managedfields.GvkParser +} + +var _ TypeConverter = &typeConverter{} + +// NewTypeConverter builds a TypeConverter from a proto.Models. This +// will automatically find the proper version of the object, and the +// corresponding schema information. +func NewTypeConverter(models proto.Models, preserveUnknownFields bool) (TypeConverter, error) { + parser, err := managedfields.NewGVKParser(models, preserveUnknownFields) + if err != nil { + return nil, err + } + return &typeConverter{parser: parser}, nil +} + +func (c *typeConverter) ObjectToTyped(obj runtime.Object) (*typed.TypedValue, error) { + gvk := obj.GetObjectKind().GroupVersionKind() + t := c.parser.Type(gvk) + if t == nil { + return nil, newNoCorrespondingTypeError(gvk) + } + switch o := obj.(type) { + case *unstructured.Unstructured: + return t.FromUnstructured(o.UnstructuredContent()) + default: + return t.FromStructured(obj) + } +} + +func (c *typeConverter) TypedToObject(value *typed.TypedValue) (runtime.Object, error) { + return valueToObject(value.AsValue()) +} + +func valueToObject(val value.Value) (runtime.Object, error) { + vu := val.Unstructured() + switch o := vu.(type) { + case map[string]any: + return &unstructured.Unstructured{Object: o}, nil + default: + return nil, fmt.Errorf("failed to convert value to unstructured for type %T", vu) + } +} + +type noCorrespondingTypeErr struct { + gvk schema.GroupVersionKind +} + +func newNoCorrespondingTypeError(gvk schema.GroupVersionKind) error { + return &noCorrespondingTypeErr{gvk: gvk} +} + +func (k *noCorrespondingTypeErr) Error() string { + return fmt.Sprintf("no corresponding type for %v", k.gvk) +} + +func isNoCorrespondingTypeError(err error) bool { + if err == nil { + return false + } + _, ok := err.(*noCorrespondingTypeErr) + return ok +} diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_versionconverter.go b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_versionconverter.go new file mode 100644 index 0000000000000..0ac1e1e874952 --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/borrowed_versionconverter.go @@ -0,0 +1,101 @@ +/* +Copyright 2018 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 fieldmanager + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/structured-merge-diff/v6/fieldpath" + "sigs.k8s.io/structured-merge-diff/v6/merge" + "sigs.k8s.io/structured-merge-diff/v6/typed" +) + +// versionConverter is an implementation of +// sigs.k8s.io/structured-merge-diff/merge.Converter +type versionConverter struct { + typeConverter TypeConverter + objectConvertor runtime.ObjectConvertor + hubGetter func(from schema.GroupVersion) schema.GroupVersion +} + +var _ merge.Converter = &versionConverter{} + +// NewVersionConverter builds a VersionConverter from a TypeConverter and an ObjectConvertor. +func newVersionConverter(t TypeConverter, o runtime.ObjectConvertor, h schema.GroupVersion) merge.Converter { + return &versionConverter{ + typeConverter: t, + objectConvertor: o, + hubGetter: func(from schema.GroupVersion) schema.GroupVersion { + return schema.GroupVersion{ + Group: from.Group, + Version: h.Version, + } + }, + } +} + +// NewCRDVersionConverter builds a VersionConverter for CRDs from a TypeConverter and an ObjectConvertor. +func newCRDVersionConverter(t TypeConverter, o runtime.ObjectConvertor, h schema.GroupVersion) merge.Converter { + return &versionConverter{ + typeConverter: t, + objectConvertor: o, + hubGetter: func(from schema.GroupVersion) schema.GroupVersion { + return h + }, + } +} + +// Convert implements sigs.k8s.io/structured-merge-diff/merge.Converter +func (v *versionConverter) Convert(object *typed.TypedValue, version fieldpath.APIVersion) (*typed.TypedValue, error) { + // Convert the smd typed value to a kubernetes object. + objectToConvert, err := v.typeConverter.TypedToObject(object) + if err != nil { + return object, err + } + + // Parse the target groupVersion. + groupVersion, err := schema.ParseGroupVersion(string(version)) + if err != nil { + return object, err + } + + // If attempting to convert to the same version as we already have, just return it. + fromVersion := objectToConvert.GetObjectKind().GroupVersionKind().GroupVersion() + if fromVersion == groupVersion { + return object, nil + } + + // Convert to internal + internalObject, err := v.objectConvertor.ConvertToVersion(objectToConvert, v.hubGetter(fromVersion)) + if err != nil { + return object, err + } + + // Convert the object into the target version + convertedObject, err := v.objectConvertor.ConvertToVersion(internalObject, groupVersion) + if err != nil { + return object, err + } + + // Convert the object back to a smd typed value and return it. + return v.typeConverter.ObjectToTyped(convertedObject) +} + +// IsMissingVersionError +func (v *versionConverter) IsMissingVersionError(err error) bool { + return runtime.IsNotRegisteredError(err) || isNoCorrespondingTypeError(err) +} diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/doc.go b/gitops-engine/pkg/diff/internal/fieldmanager/doc.go new file mode 100644 index 0000000000000..a1bdd5991e354 --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/doc.go @@ -0,0 +1,25 @@ +/* +Package fieldmanager is a special package as its main purpose +is to expose the dependencies required by structured-merge-diff +library to calculate diffs when server-side apply option is enabled. +The dependency tree necessary to have a `merge.Updater` instance +isn't trivial to implement and the strategy used is borrowing a copy +from Kubernetes apiserver codebase in order to expose the required +functionality. + +Below there is a list of borrowed files and a reference to which +package/file in Kubernetes they were copied from: + +- borrowed_fields.go: k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/fields.go +- borrowed_managedfields.go: k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/managedfields.go +- borrowed_typeconverter.go: k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/typeconverter.go +- borrowed_versionconverter.go: k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/versionconverter.go + +In order to keep maintenance as minimal as possible the borrowed +files are verbatim copy from Kubernetes. The private objects that +need to be exposed are wrapped in the wrapper.go file. Updating +the borrowed files should be trivial in most cases but must be done +manually as we have no control over future refactorings Kubernetes +might do. +*/ +package fieldmanager diff --git a/gitops-engine/pkg/diff/internal/fieldmanager/wrapper.go b/gitops-engine/pkg/diff/internal/fieldmanager/wrapper.go new file mode 100644 index 0000000000000..9f26aed07fe62 --- /dev/null +++ b/gitops-engine/pkg/diff/internal/fieldmanager/wrapper.go @@ -0,0 +1,22 @@ +package fieldmanager + +/* +In order to keep maintenance as minimal as possible the borrowed +files in this package are verbatim copy from Kubernetes. The +private objects that need to be exposed are wrapped and exposed +in this file. +*/ + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/managedfields" + "sigs.k8s.io/structured-merge-diff/v6/merge" +) + +// NewVersionConverter will expose the version converter from the +// borrowed private function from k8s apiserver handler. +func NewVersionConverter(gvkParser *managedfields.GvkParser, o runtime.ObjectConvertor, h schema.GroupVersion) merge.Converter { + tc := &typeConverter{parser: gvkParser} + return newVersionConverter(tc, o, h) +} diff --git a/gitops-engine/pkg/diff/mocks/ServerSideDryRunner.go b/gitops-engine/pkg/diff/mocks/ServerSideDryRunner.go new file mode 100644 index 0000000000000..321ecf5fc9c28 --- /dev/null +++ b/gitops-engine/pkg/diff/mocks/ServerSideDryRunner.go @@ -0,0 +1,58 @@ +// Code generated by mockery v2.38.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +// ServerSideDryRunner is an autogenerated mock type for the ServerSideDryRunner type +type ServerSideDryRunner struct { + mock.Mock +} + +// Run provides a mock function with given fields: ctx, obj, manager +func (_m *ServerSideDryRunner) Run(ctx context.Context, obj *unstructured.Unstructured, manager string) (string, error) { + ret := _m.Called(ctx, obj, manager) + + if len(ret) == 0 { + panic("no return value specified for Run") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *unstructured.Unstructured, string) (string, error)); ok { + return rf(ctx, obj, manager) + } + if rf, ok := ret.Get(0).(func(context.Context, *unstructured.Unstructured, string) string); ok { + r0 = rf(ctx, obj, manager) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, *unstructured.Unstructured, string) error); ok { + r1 = rf(ctx, obj, manager) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewServerSideDryRunner creates a new instance of ServerSideDryRunner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewServerSideDryRunner(t interface { + mock.TestingT + Cleanup(func()) +}) *ServerSideDryRunner { + mock := &ServerSideDryRunner{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/gitops-engine/pkg/diff/testdata/aggr-clusterrole-config.json b/gitops-engine/pkg/diff/testdata/aggr-clusterrole-config.json new file mode 100644 index 0000000000000..c28eaa13963e1 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/aggr-clusterrole-config.json @@ -0,0 +1,19 @@ +{ + "apiVersion": "rbac.authorization.k8s.io/v1", + "kind": "ClusterRole", + "metadata": { + "name": "test-clusterrole", + "labels": { + "app.kubernetes.io/instance": "clusterroles" + } + }, + "aggregationRule": { + "clusterRoleSelectors": [ + { + "matchLabels": { + "rbac.example.com/aggregate-to-test": "true" + } + } + ] + } +} diff --git a/gitops-engine/pkg/diff/testdata/aggr-clusterrole-live.json b/gitops-engine/pkg/diff/testdata/aggr-clusterrole-live.json new file mode 100644 index 0000000000000..5fddf3a98849a --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/aggr-clusterrole-live.json @@ -0,0 +1,55 @@ +{ + "aggregationRule": { + "clusterRoleSelectors": [ + { + "matchLabels": { + "rbac.example.com/aggregate-to-test": "true" + } + } + ] + }, + "apiVersion": "rbac.authorization.k8s.io/v1", + "kind": "ClusterRole", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"aggregationRule\":{\"clusterRoleSelectors\":[{\"matchLabels\":{\"rbac.example.com/aggregate-to-test\":\"true\"}}]},\"apiVersion\":\"rbac.authorization.k8s.io/v1\",\"kind\":\"ClusterRole\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"clusterroles\"},\"name\":\"test-clusterrole\"},\"rules\":[{\"apiGroups\":[\"\"],\"resources\":[\"deployments\"],\"verbs\":[\"get\",\"list\"]}]}\n" + }, + "creationTimestamp": "2020-02-02T17:18:54Z", + "labels": { + "app.kubernetes.io/instance": "clusterroles" + }, + "name": "test-clusterrole", + "resourceVersion": "5108751", + "selfLink": "/apis/rbac.authorization.k8s.io/v1/clusterroles/test-clusterrole", + "uid": "418e7818-ec49-49f6-ada0-d1fccf679bf6" + }, + "rules": [ + { + "apiGroups": [ + "" + ], + "resources": [ + "services", + "endpoints" + ], + "verbs": [ + "get", + "list", + "watch" + ] + }, + { + "apiGroups": [ + "" + ], + "resources": [ + "pods" + ], + "verbs": [ + "get", + "list", + "watch" + ] + } + ] +} diff --git a/gitops-engine/pkg/diff/testdata/data.go b/gitops-engine/pkg/diff/testdata/data.go new file mode 100644 index 0000000000000..1de1618273968 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/data.go @@ -0,0 +1,80 @@ +package testdata + +import _ "embed" + +var ( + //go:embed smd-service-config.yaml + ServiceConfigYAML string + + //go:embed smd-service-live.yaml + ServiceLiveYAML string + + //go:embed smd-service-config-2-ports.yaml + ServiceConfigWith2Ports string + + //go:embed smd-service-live-with-type.yaml + LiveServiceWithTypeYAML string + + //go:embed smd-service-config-ports.yaml + ServiceConfigWithSamePortsYAML string + + //go:embed smd-deploy-live.yaml + DeploymentLiveYAML string + + //go:embed smd-deploy-config.yaml + DeploymentConfigYAML string + + //go:embed smd-deploy2-live.yaml + Deployment2LiveYAML string + + //go:embed smd-deploy2-config.yaml + Deployment2ConfigYAML string + + //go:embed smd-deploy2-predicted-live.json + Deployment2PredictedLiveJSONSSD string + + // OpenAPIV2Doc is a binary representation of the openapi + // document available in a given k8s instance. To update + // this file the following commands can be executed: + // kubectl proxy --port=7777 & + // curl -s -H Accept:application/com.github.proto-openapi.spec.v2@v1.0+protobuf http://localhost:7777/openapi/v2 > openapiv2.bin + // + //go:embed openapiv2.bin + OpenAPIV2Doc []byte + + //go:embed ssd-service-config.yaml + ServiceConfigYAMLSSD string + + //go:embed ssd-service-live.yaml + ServiceLiveYAMLSSD string + + //go:embed ssd-service-predicted-live.json + ServicePredictedLiveJSONSSD string + + //go:embed ssd-deploy-nested-config.yaml + DeploymentNestedConfigYAMLSSD string + + //go:embed ssd-deploy-nested-live.yaml + DeploymentNestedLiveYAMLSSD string + + //go:embed ssd-deploy-nested-predicted-live.json + DeploymentNestedPredictedLiveJSONSSD string + + //go:embed ssd-deploy-with-manual-apply-config.yaml + DeploymentApplyConfigYAMLSSD string + + //go:embed ssd-deploy-with-manual-apply-live.yaml + DeploymentApplyLiveYAMLSSD string + + //go:embed ssd-deploy-with-manual-apply-predicted-live.json + DeploymentApplyPredictedLiveJSONSSD string + + //go:embed ssd-svc-label-live.yaml + ServiceLiveLabelYAMLSSD string + + //go:embed ssd-svc-no-label-config.yaml + ServiceConfigNoLabelYAMLSSD string + + //go:embed ssd-svc-no-label-predicted-live.json + ServicePredictedLiveNoLabelJSONSSD string +) diff --git a/gitops-engine/pkg/diff/testdata/deployment-config.json b/gitops-engine/pkg/diff/testdata/deployment-config.json new file mode 100644 index 0000000000000..627df67649f90 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/deployment-config.json @@ -0,0 +1,49 @@ +{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "labels": { + "app.kubernetes.io/instance": "guestbook" + }, + "name": "guestbook-ui", + "namespace": "default" + }, + "spec": { + "replicas": 1, + "revisionHistoryLimit": 3, + "selector": { + "matchLabels": { + "app": "guestbook-ui" + } + }, + "strategy": { + "type": "RollingUpdate" + }, + "template": { + "metadata": { + "labels": { + "app": "guestbook-ui" + } + }, + "spec": { + "containers": [ + { + "image": "gcr.io/heptio-images/ks-guestbook-demo:0.2", + "name": "guestbook-ui", + "ports": [ + { + "containerPort": 80 + } + ], + "env": [ + { + "name": "VAR1", + "value": "something" + } + ] + } + ] + } + } + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/deployment-live.json b/gitops-engine/pkg/diff/testdata/deployment-live.json new file mode 100644 index 0000000000000..7183a84995ed2 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/deployment-live.json @@ -0,0 +1,108 @@ +{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "annotations": { + "deployment.kubernetes.io/revision": "5", + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"apps/v1\",\"kind\":\"Deployment\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"guestbook\"},\"name\":\"guestbook-ui\",\"namespace\":\"default\"},\"spec\":{\"replicas\":1,\"revisionHistoryLimit\":3,\"selector\":{\"matchLabels\":{\"app\":\"guestbook-ui\"}},\"template\":{\"metadata\":{\"labels\":{\"app\":\"guestbook-ui\"}},\"spec\":{\"containers\":[{\"env\":[{\"name\":\"VAR1\",\"value\":\"something\"}],\"image\":\"gcr.io/heptio-images/ks-guestbook-demo:0.2\",\"name\":\"guestbook-ui\",\"ports\":[{\"containerPort\":80}]}]}}}}\n" + }, + "creationTimestamp": "2020-06-25T19:25:05Z", + "generation": 5, + "labels": { + "app.kubernetes.io/instance": "guestbook" + }, + "name": "guestbook-ui", + "namespace": "default", + "resourceVersion": "1208550", + "selfLink": "/apis/apps/v1/namespaces/default/deployments/guestbook-ui", + "uid": "165ca30d-8dca-44ae-b0ba-6ea26160ac9f" + }, + "spec": { + "progressDeadlineSeconds": 600, + "replicas": 1, + "revisionHistoryLimit": 3, + "selector": { + "matchLabels": { + "app": "guestbook-ui" + } + }, + "strategy": { + "rollingUpdate": { + "maxSurge": "25%", + "maxUnavailable": "25%" + }, + "type": "RollingUpdate" + }, + "template": { + "metadata": { + "creationTimestamp": null, + "labels": { + "app": "guestbook-ui" + } + }, + "spec": { + "containers": [ + { + "env": [ + { + "name": "VAR2", + "valueFrom": { + "fieldRef": { + "apiVersion": "v1", + "fieldPath": "metadata.name" + } + } + }, + { + "name": "VAR1", + "value": "something" + } + ], + "image": "gcr.io/heptio-images/ks-guestbook-demo:0.2", + "imagePullPolicy": "IfNotPresent", + "name": "guestbook-ui", + "ports": [ + { + "containerPort": 80, + "protocol": "TCP" + } + ], + "resources": {}, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File" + } + ], + "dnsPolicy": "ClusterFirst", + "restartPolicy": "Always", + "schedulerName": "default-scheduler", + "securityContext": {}, + "terminationGracePeriodSeconds": 30 + } + } + }, + "status": { + "availableReplicas": 1, + "conditions": [ + { + "lastTransitionTime": "2020-06-25T19:25:07Z", + "lastUpdateTime": "2020-06-25T19:25:07Z", + "message": "Deployment has minimum availability.", + "reason": "MinimumReplicasAvailable", + "status": "True", + "type": "Available" + }, + { + "lastTransitionTime": "2020-06-25T19:25:05Z", + "lastUpdateTime": "2020-06-30T19:39:35Z", + "message": "ReplicaSet \"guestbook-ui-6f7c7fc4b6\" has successfully progressed.", + "reason": "NewReplicaSetAvailable", + "status": "True", + "type": "Progressing" + } + ], + "observedGeneration": 5, + "readyReplicas": 1, + "replicas": 1, + "updatedReplicas": 1 + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/elasticsearch-config.json b/gitops-engine/pkg/diff/testdata/elasticsearch-config.json new file mode 100644 index 0000000000000..00b34af935942 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/elasticsearch-config.json @@ -0,0 +1,217 @@ +{ + "apiVersion": "apps/v1beta1", + "kind": "StatefulSet", + "metadata": { + "labels": { + "app": "elasticsearch", + "app.kubernetes.io/instance": "elasticsearch4", + "chart": "elasticsearch-1.7.0", + "component": "data", + "heritage": "Tiller", + "release": "elasticsearch4" + }, + "name": "elasticsearch4-data" + }, + "spec": { + "replicas": 2, + "selector": { + "matchLabels": { + "app": "elasticsearch", + "component": "data", + "release": "elasticsearch4" + } + }, + "serviceName": "elasticsearch4-data", + "template": { + "metadata": { + "labels": { + "app": "elasticsearch", + "app.kubernetes.io/instance": "elasticsearch4", + "component": "data", + "release": "elasticsearch4" + } + }, + "spec": { + "affinity": { + "podAntiAffinity": { + "preferredDuringSchedulingIgnoredDuringExecution": [ + { + "podAffinityTerm": { + "labelSelector": { + "matchLabels": { + "app": "elasticsearch", + "component": "data", + "release": "elasticsearch4" + } + }, + "topologyKey": "kubernetes.io/hostname" + }, + "weight": 1 + } + ] + } + }, + "containers": [ + { + "env": [ + { + "name": "DISCOVERY_SERVICE", + "value": "elasticsearch4-discovery" + }, + { + "name": "NODE_MASTER", + "value": "false" + }, + { + "name": "PROCESSORS", + "valueFrom": { + "resourceFieldRef": { + "resource": "limits.cpu" + } + } + }, + { + "name": "ES_JAVA_OPTS", + "value": "-Djava.net.preferIPv4Stack=true -Xms1536m -Xmx1536m" + }, + { + "name": "MINIMUM_MASTER_NODES", + "value": "2" + } + ], + "image": "docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0", + "imagePullPolicy": "IfNotPresent", + "lifecycle": { + "postStart": { + "exec": { + "command": [ + "/bin/bash", + "/post-start-hook.sh" + ] + } + }, + "preStop": { + "exec": { + "command": [ + "/bin/bash", + "/pre-stop-hook.sh" + ] + } + } + }, + "name": "elasticsearch", + "ports": [ + { + "containerPort": 9300, + "name": "transport" + } + ], + "readinessProbe": { + "httpGet": { + "path": "/_cluster/health?local=true", + "port": 9200 + }, + "initialDelaySeconds": 5 + }, + "resources": { + "limits": { + "cpu": "1" + }, + "requests": { + "cpu": "25m", + "memory": "1536Mi" + } + }, + "volumeMounts": [ + { + "mountPath": "/usr/share/elasticsearch/data", + "name": "data" + }, + { + "mountPath": "/usr/share/elasticsearch/config/elasticsearch.yml", + "name": "config", + "subPath": "elasticsearch.yml" + }, + { + "mountPath": "/pre-stop-hook.sh", + "name": "config", + "subPath": "pre-stop-hook.sh" + }, + { + "mountPath": "/post-start-hook.sh", + "name": "config", + "subPath": "post-start-hook.sh" + } + ] + } + ], + "initContainers": [ + { + "command": [ + "sysctl", + "-w", + "vm.max_map_count=262144" + ], + "image": "busybox", + "imagePullPolicy": "Always", + "name": "sysctl", + "securityContext": { + "privileged": true + } + }, + { + "command": [ + "/bin/bash", + "-c", + "chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/data && chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/logs" + ], + "image": "docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0", + "imagePullPolicy": "IfNotPresent", + "name": "chown", + "securityContext": { + "runAsUser": 0 + }, + "volumeMounts": [ + { + "mountPath": "/usr/share/elasticsearch/data", + "name": "data" + } + ] + } + ], + "securityContext": { + "fsGroup": 1000 + }, + "terminationGracePeriodSeconds": 3600, + "volumes": [ + { + "configMap": { + "name": "elasticsearch4" + }, + "name": "config" + } + ] + } + }, + "updateStrategy": { + "type": "OnDelete" + }, + "volumeClaimTemplates": [ + { + "metadata": { + "name": "data" + }, + "spec": { + "accessModes": [ + "ReadWriteOnce" + ], + "resources": { + "requests": { + "storage": "30Gi" + } + } + } + } + ] + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/elasticsearch-live.json b/gitops-engine/pkg/diff/testdata/elasticsearch-live.json new file mode 100644 index 0000000000000..4c7f87f7216fc --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/elasticsearch-live.json @@ -0,0 +1,261 @@ +{ + "apiVersion": "apps/v1beta1", + "kind": "StatefulSet", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"apps/v1beta1\",\"kind\":\"StatefulSet\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"elasticsearch\",\"app.kubernetes.io/instance\":\"elasticsearch4\",\"chart\":\"elasticsearch-1.7.0\",\"component\" :\"data\",\"heritage\":\"Tiller\",\"release\":\"elasticsearch4\"},\"name\":\"elasticsearch4-data\",\"namespace\":\"elasticsearch4\"},\"spec\":{\"replicas\":2,\"selector\":{\"matchLabels\":{\"app\":\"elasticsearch\",\"component\":\"data\",\"release\":\"elasticsearch4\"}},\"serviceName\":\"elasticsearch4-data\",\"template\":{\"metadata\":{\"labels\":{\"app\":\"elasticsearch\",\"app.kubernetes.io/instance\":\"elasticsearch4\",\"component\":\"data\",\"release\":\"elasticsearch4\"}},\"spec\":{\"affinity\":{\"podAntiAffinity\":{\"preferredDuringSchedulingIgnoredDuringExecution\":[{\"podAffinityTerm\":{\"labelSelector\":{\"matchLabels\":{\"app\":\"elasticsearch\",\"component\":\"data\",\"release\":\"elasticsearch4\"}},\"topologyKey\":\"kubernetes.io/hostname\"},\"weight\":1}]}},\"containers\":[{\"env\":[{\"name\":\"DISCOVERY_SERVICE\",\"value\":\"elasticsearch4-discovery\"},{\"name\":\"NODE_MASTER\",\"value\":\"false\"},{\"name\":\"PROCESSORS\",\"valueFrom\":{\"resourceFieldRef\":{\"resource\":\"limits.cpu\"}}},{\"name\":\"ES_JAVA_OPTS\",\"value\":\"-Djava.net.preferIPv4Stack=true -Xms1536m -Xmx1536m\"},{\"name\":\"MINIMUM_MASTER_NODES\",\"value\":\"2\"}],\"image\":\"docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0\",\"imagePullPolicy\":\"IfNotPresent\",\"lifecycle\":{\"postStart\":{\"exec\":{\"command\":[\"/bin/bash\",\"/post-start-hook.sh\"]}},\"preStop\":{\"exec\":{\"command\":[\"/bin/bash\",\"/pre-stop-hook.sh\"]}}},\"name\":\"elasticsearch\",\"ports\":[{\"containerPort\":9300,\"name\":\"transport\"}],\"readinessProbe\":{\"httpGet\":{\"path\":\"/_cluster/health?local=true\",\"port\":9200},\"initialDelaySeconds\":5},\"resources\":{\"limits\":{\"cpu\":\"1\"},\"requests\":{\"cpu\":\"25m\",\"memory\":\"1536Mi\"}},\"volumeMounts\":[{\"mountPath\":\"/usr/share/elasticsearch/data\",\"name\":\"data\"},{\"mountPath\":\"/usr/share/elasticsearch/config/elasticsearch.yml\",\"name\":\"config\",\"subPath\":\"elasticsearch.yml\"},{\"mountPath\":\"/pre-stop-hook.sh\",\"name\":\"config\",\"subPath\":\"pre-stop-hook.sh\"},{\"mountPath\":\"/post-start-hook.sh\",\"name\":\"config\",\"subPath\":\"post-start-hook.sh\"}]}],\"initContainers\":[{\"command\":[\"sysctl\",\"-w\",\"vm.max_map_count=262144\"],\"image\":\"busybox\",\"imagePullPolicy\":\"Always\",\"name\":\"sysctl\",\"securityContext\":{\"privileged\":true}},{\"command\":[\"/bin/bash\",\"-c\",\"chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/data \\u0026\\u0026 chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/logs\"],\"image\":\"docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0\",\"imagePullPolicy\":\"IfNotPresent\",\"name\":\"chown\",\"securityContext\":{\"runAsUser\":0},\"volumeMounts\":[{\"mountPath\":\"/usr/share/elasticsearch/data\",\"name\":\"data\"}]}],\"securityContext\":{\"fsGroup\":1000},\"terminationGracePeriodSeconds\":3600,\"volumes\":[{\"configMap\":{\"name\":\"elasticsearch4\"},\"name\":\"config\"}]}},\"updateStrategy\":{\"type\":\"OnDelete\"},\"volumeClaimTemplates\":[{\"metadata\":{\"name\":\"data\"},\"spec\":{\"accessModes\":[\"ReadWriteOnce\"],\"resources\":{\"requests\":{\"storage\":\"30Gi\"}}}}]}}\n" + }, + "creationTimestamp": "2018-09-14T22:20:41Z", + "generation": 1, + "labels": { + "app": "elasticsearch", + "app.kubernetes.io/instance": "elasticsearch4", + "chart": "elasticsearch-1.7.0", + "component": "data", + "heritage": "Tiller", + "release": "elasticsearch4" + }, + "name": "elasticsearch4-data", + "namespace": "elasticsearch4", + "resourceVersion": "10689842", + "selfLink": "/apis/apps/v1beta1/namespaces/elasticsearch4/statefulsets/elasticsearch4-data", + "uid": "6a850cf9-b86c-11e8-bbd2-42010a8a00bb" + }, + "spec": { + "podManagementPolicy": "OrderedReady", + "replicas": 2, + "revisionHistoryLimit": 10, + "selector": { + "matchLabels": { + "app": "elasticsearch", + "component": "data", + "release": "elasticsearch4" + } + }, + "serviceName": "elasticsearch4-data", + "template": { + "metadata": { + "creationTimestamp": null, + "labels": { + "app": "elasticsearch", + "app.kubernetes.io/instance": "elasticsearch4", + "component": "data", + "release": "elasticsearch4" + } + }, + "spec": { + "affinity": { + "podAntiAffinity": { + "preferredDuringSchedulingIgnoredDuringExecution": [ + { + "podAffinityTerm": { + "labelSelector": { + "matchLabels": { + "app": "elasticsearch", + "component": "data", + "release": "elasticsearch4" + } + }, + "topologyKey": "kubernetes.io/hostname" + }, + "weight": 1 + } + ] + } + }, + "containers": [ + { + "env": [ + { + "name": "DISCOVERY_SERVICE", + "value": "elasticsearch4-discovery" + }, + { + "name": "NODE_MASTER", + "value": "false" + }, + { + "name": "PROCESSORS", + "valueFrom": { + "resourceFieldRef": { + "divisor": "0", + "resource": "limits.cpu" + } + } + }, + { + "name": "ES_JAVA_OPTS", + "value": "-Djava.net.preferIPv4Stack=true -Xms1536m -Xmx1536m" + }, + { + "name": "MINIMUM_MASTER_NODES", + "value": "2" + } + ], + "image": "docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0", + "imagePullPolicy": "IfNotPresent", + "lifecycle": { + "postStart": { + "exec": { + "command": [ + "/bin/bash", + "/post-start-hook.sh" + ] + } + }, + "preStop": { + "exec": { + "command": [ + "/bin/bash", + "/pre-stop-hook.sh" + ] + } + } + }, + "name": "elasticsearch", + "ports": [ + { + "containerPort": 9300, + "name": "transport", + "protocol": "TCP" + } + ], + "readinessProbe": { + "failureThreshold": 3, + "httpGet": { + "path": "/_cluster/health?local=true", + "port": 9200, + "scheme": "HTTP" + }, + "initialDelaySeconds": 5, + "periodSeconds": 10, + "successThreshold": 1, + "timeoutSeconds": 1 + }, + "resources": { + "limits": { + "cpu": "1" + }, + "requests": { + "cpu": "25m", + "memory": "1536Mi" + } + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File", + "volumeMounts": [ + { + "mountPath": "/usr/share/elasticsearch/data", + "name": "data" + }, + { + "mountPath": "/usr/share/elasticsearch/config/elasticsearch.yml", + "name": "config", + "subPath": "elasticsearch.yml" + }, + { + "mountPath": "/pre-stop-hook.sh", + "name": "config", + "subPath": "pre-stop-hook.sh" + }, + { + "mountPath": "/post-start-hook.sh", + "name": "config", + "subPath": "post-start-hook.sh" + } + ] + } + ], + "dnsPolicy": "ClusterFirst", + "initContainers": [ + { + "command": [ + "sysctl", + "-w", + "vm.max_map_count=262144" + ], + "image": "busybox", + "imagePullPolicy": "Always", + "name": "sysctl", + "resources": {}, + "securityContext": { + "privileged": true + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File" + }, + { + "command": [ + "/bin/bash", + "-c", + "chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/data && chown -R elasticsearch:elasticsearch /usr/share/elasticsearch/logs" + ], + "image": "docker.elastic.co/elasticsearch/elasticsearch-oss:6.4.0", + "imagePullPolicy": "IfNotPresent", + "name": "chown", + "resources": {}, + "securityContext": { + "runAsUser": 0 + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File", + "volumeMounts": [ + { + "mountPath": "/usr/share/elasticsearch/data", + "name": "data" + } + ] + } + ], + "restartPolicy": "Always", + "schedulerName": "default-scheduler", + "securityContext": { + "fsGroup": 1000 + }, + "terminationGracePeriodSeconds": 3600, + "volumes": [ + { + "configMap": { + "defaultMode": 420, + "name": "elasticsearch4" + }, + "name": "config" + } + ] + } + }, + "updateStrategy": { + "type": "OnDelete" + }, + "volumeClaimTemplates": [ + { + "metadata": { + "creationTimestamp": null, + "name": "data" + }, + "spec": { + "accessModes": [ + "ReadWriteOnce" + ], + "resources": { + "requests": { + "storage": "30Gi" + } + } + }, + "status": { + "phase": "Pending" + } + } + ] + }, + "status": { + "collisionCount": 0, + "currentReplicas": 2, + "currentRevision": "elasticsearch4-data-74f6d9c899", + "observedGeneration": 1, + "readyReplicas": 2, + "replicas": 2, + "updateRevision": "elasticsearch4-data-74f6d9c899" + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/endpoints-config.json b/gitops-engine/pkg/diff/testdata/endpoints-config.json new file mode 100644 index 0000000000000..4dc188a9d3513 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/endpoints-config.json @@ -0,0 +1,55 @@ +{ + "apiVersion": "v1", + "kind": "Endpoints", + "metadata": { + "annotations": { + "description": "A workaround to support a set of backend IPs for solr", + "linkerd.io/inject": "disabled" + }, + "labels": { + "app.kubernetes.io/instance": "guestbook" + }, + "name": "solrcloud", + "namespace": "default" + }, + "subsets": [ + { + "addresses": [ + { + "ip": "172.20.10.97" + }, + { + "ip": "172.20.10.98" + }, + { + "ip": "172.20.10.99" + }, + { + "ip": "172.20.10.100" + }, + { + "ip": "172.20.10.101" + } + ], + "ports": [ + { + "name": "solr-http", + "port": 8080 + }, + { + "name": "solr-https", + "port": 8443 + }, + { + "name": "solr-node", + "port": 8983, + "protocol": "UDP" + }, + { + "name": "solr-zookeeper", + "port": 9983 + } + ] + } + ] +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/endpoints-live.json b/gitops-engine/pkg/diff/testdata/endpoints-live.json new file mode 100644 index 0000000000000..55e06eb82a443 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/endpoints-live.json @@ -0,0 +1,86 @@ +{ + "apiVersion": "v1", + "kind": "Endpoints", + "metadata": { + "annotations": { + "description": "A workaround to support a set of backend IPs for solr", + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"v1\",\"kind\":\"Endpoints\",\"metadata\":{\"annotations\":{\"description\":\"A workaround to support a set of backend IPs for solr\",\"linkerd.io/inject\":\"disabled\"},\"labels\":{\"app.kubernetes.io/instance\":\"guestbook\"},\"name\":\"solrcloud\",\"namespace\":\"default\"},\"subsets\":[{\"addresses\":[{\"ip\":\"172.20.10.97\"},{\"ip\":\"172.20.10.98\"},{\"ip\":\"172.20.10.99\"},{\"ip\":\"172.20.10.100\"},{\"ip\":\"172.20.10.101\"}],\"ports\":[{\"name\":\"solr-http\",\"port\":8080},{\"name\":\"solr-https\",\"port\":8443},{\"name\":\"solr-node\",\"port\":8983,\"protocol\":\"UDP\"},{\"name\":\"solr-zookeeper\",\"port\":9983}]}]}\n", + "linkerd.io/inject": "disabled" + }, + "creationTimestamp": null, + "labels": { + "app.kubernetes.io/instance": "guestbook" + }, + "managedFields": [ + { + "apiVersion": "v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:annotations": { + ".": {}, + "f:description": {}, + "f:kubectl.kubernetes.io/last-applied-configuration": {}, + "f:linkerd.io/inject": {} + }, + "f:labels": { + ".": {}, + "f:app.kubernetes.io/instance": {} + } + }, + "f:subsets": {} + }, + "manager": "main", + "operation": "Update", + "time": null + } + ], + "name": "solrcloud", + "namespace": "default", + "resourceVersion": "2336", + "uid": "439a86ee-cbf9-4717-9ce3-d44079333a27" + }, + "subsets": [ + { + "addresses": [ + { + "ip": "172.20.10.97" + }, + { + "ip": "172.20.10.98" + }, + { + "ip": "172.20.10.99" + }, + { + "ip": "172.20.10.100" + }, + { + "ip": "172.20.10.101" + } + ], + "ports": [ + { + "name": "solr-http", + "port": 8080, + "protocol": "TCP" + }, + { + "name": "solr-https", + "port": 8443, + "protocol": "TCP" + }, + { + "name": "solr-node", + "port": 8983, + "protocol": "UDP" + }, + { + "name": "solr-zookeeper", + "port": 9983, + "protocol": "TCP" + } + ] + } + ] +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/grafana-clusterrole-config.json b/gitops-engine/pkg/diff/testdata/grafana-clusterrole-config.json new file mode 100644 index 0000000000000..03a502dece461 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/grafana-clusterrole-config.json @@ -0,0 +1,14 @@ +{ + "kind": "ClusterRole", + "apiVersion": "rbac.authorization.k8s.io/v1", + "metadata": { + "labels": { + "app": "grafana", + "chart": "grafana-1.21.2", + "release": "grafana", + "heritage": "Tiller" + }, + "name": "grafana-clusterrole" + }, + "rules": [] +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/grafana-clusterrole-live.json b/gitops-engine/pkg/diff/testdata/grafana-clusterrole-live.json new file mode 100644 index 0000000000000..db12277233e90 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/grafana-clusterrole-live.json @@ -0,0 +1,21 @@ +{ + "apiVersion": "rbac.authorization.k8s.io/v1", + "kind": "ClusterRole", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"rbac.authorization.k8s.io/v1\",\"kind\":\"ClusterRole\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"grafana\",\"chart\":\"grafana-1.21.2\",\"heritage\":\"Tiller\",\"release\":\"grafana\"},\"name\":\"grafana-clusterrole\"},\"rules\":[]}\n" + }, + "creationTimestamp": "2018-12-26T23:26:41Z", + "labels": { + "app": "grafana", + "chart": "grafana-1.21.2", + "heritage": "Tiller", + "release": "grafana" + }, + "name": "grafana-clusterrole", + "resourceVersion": "13174", + "selfLink": "/apis/rbac.authorization.k8s.io/v1/clusterroles/grafana-clusterrole", + "uid": "b30316d3-0965-11e9-9673-ae0a6e5594a2" + }, + "rules": null +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-config.json b/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-config.json new file mode 100644 index 0000000000000..3b062d93961e4 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-config.json @@ -0,0 +1,52 @@ +{ + "apiVersion": "admissionregistration.k8s.io/v1beta1", + "kind": "MutatingWebhookConfiguration", + "metadata": { + "annotations": { + "cert-manager.io/inject-apiserver-ca": "true" + }, + "labels": { + "app": "webhook", + "app.kubernetes.io/instance": "cert-manager", + "app.kubernetes.io/managed-by": "Tiller", + "app.kubernetes.io/name": "webhook", + "helm.sh/chart": "cert-manager-v0.11.0" + }, + "name": "cert-manager-webhook" + }, + "webhooks": [ + { + "clientConfig": { + "service": { + "name": "kubernetes", + "namespace": "default", + "path": "/apis/webhook.cert-manager.io/v1beta1/mutations" + } + }, + "failurePolicy": "Fail", + "name": "webhook.cert-manager.io", + "rules": [ + { + "apiGroups": [ + "cert-manager.io" + ], + "apiVersions": [ + "v1alpha2" + ], + "operations": [ + "CREATE", + "UPDATE" + ], + "resources": [ + "certificates", + "issuers", + "clusterissuers", + "orders", + "challenges", + "certificaterequests" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-live.json b/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-live.json new file mode 100644 index 0000000000000..59b341cdf6ef9 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/mutatingwebhookconfig-live.json @@ -0,0 +1,70 @@ +{ + "apiVersion": "admissionregistration.k8s.io/v1beta1", + "kind": "MutatingWebhookConfiguration", + "metadata": { + "annotations": { + "cert-manager.io/inject-apiserver-ca": "true", + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"admissionregistration.k8s.io/v1beta1\",\"kind\":\"MutatingWebhookConfiguration\",\"metadata\":{\"annotations\":{\"cert-manager.io/inject-apiserver-ca\":\"true\"},\"labels\":{\"app\":\"webhook\",\"app.kubernetes.io/instance\":\"cert-manager\",\"app.kubernetes.io/managed-by\":\"Tiller\",\"app.kubernetes.io/name\":\"webhook\",\"helm.sh/chart\":\"cert-manager-v0.11.0\"},\"name\":\"cert-manager-webhook\"},\"webhooks\":[{\"clientConfig\":{\"service\":{\"name\":\"kubernetes\",\"namespace\":\"default\",\"path\":\"/apis/webhook.cert-manager.io/v1beta1/mutations\"}},\"failurePolicy\":\"Fail\",\"name\":\"webhook.cert-manager.io\",\"rules\":[{\"apiGroups\":[\"cert-manager.io\"],\"apiVersions\":[\"v1alpha2\"],\"operations\":[\"CREATE\",\"UPDATE\"],\"resources\":[\"certificates\",\"issuers\",\"clusterissuers\",\"orders\",\"challenges\",\"certificaterequests\"]}]}]}\n" + }, + "creationTimestamp": "2019-11-13T22:18:01Z", + "generation": 2, + "labels": { + "app": "webhook", + "app.kubernetes.io/instance": "cert-manager", + "app.kubernetes.io/managed-by": "Tiller", + "app.kubernetes.io/name": "webhook", + "helm.sh/chart": "cert-manager-v0.11.0" + }, + "name": "cert-manager-webhook", + "resourceVersion": "192158268", + "selfLink": "/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/cert-manager-webhook", + "uid": "746a6ca1-0663-11ea-b4b2-42010a800164" + }, + "webhooks": [ + { + "admissionReviewVersions": [ + "v1beta1" + ], + "clientConfig": { + "caBundle": "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURERENDQWZTZ0F3SUJBZ0lSQU5iM3pUUEs0VlVmdnpyMHBteTZLSFV3RFFZSktvWklodmNOQVFFTEJRQXcKTHpFdE1Dc0dBMVVFQXhNa1lqQXlNemc0TnpNdE56Z3pNaTAwTVRFMkxUZzNaakV0T1RNeE9HSmtaV0ZtTTJJeQpNQjRYRFRFNE1EVXhNREl3TlRNMU1Wb1hEVEl6TURVd09USXhOVE0xTVZvd0x6RXRNQ3NHQTFVRUF4TWtZakF5Ck16ZzROek10Tnpnek1pMDBNVEUyTFRnM1pqRXRPVE14T0dKa1pXRm1NMkl5TUlJQklqQU5CZ2txaGtpRzl3MEIKQVFFRkFBT0NBUThBTUlJQkNnS0NBUUVBdWFrM2VleHFHS3g2dEJ2cExVdGgzSUlPQVBrVHd2bkVobER5dUFwOQpDY0tVU2JsOUR3VnVyYUtrYkZSdFZhM0xpaDhGQmZ0aDhETWI3RkxoNEZ5d1JpbDNJUEhWaEZacTFvQi9aSVQxCitDUlN6NXZXZWlVeGZCM0l5L05wSTBleFVHVVAzV2N2bHFiQU9odVhXRVo5OTB0NVpiWE9GYi9hcm9sU3hyQ0cKUkFQcUhzSlNoa3kyV3FNWnkyQ29yZjV3ZTZtZmVJcFpRUmlJOWd3eWN4S2ZWbmtrT28vRlhvQjYvbnJPRlNmVwpacmJvYmVxRWsvRFB3akRDdXY4aEpjajlFdjRwVytSZjRTakRVSjBBYWZMVU1yQ05qREtXUHJoYlRTMHpBdGlKClhLdmttVFFtWWZlYjVESEJUbmw2THJoN1FSanBsTlk1MW1vZ1MvSDBOb2trZndJREFRQUJveU13SVRBT0JnTlYKSFE4QkFmOEVCQU1DQWdRd0R3WURWUjBUQVFIL0JBVXdBd0VCL3pBTkJna3Foa2lHOXcwQkFRc0ZBQU9DQVFFQQpZdC93bVlubUw2RzJySm1PWVY3N1ZQdEMrN25TKzhUbmVkbkFlNFhLSUF6alk3RTNLazdvSk5uT1VxT2V5a2hpClVuRXhpNWRmTis0b0Z1TDFKd3lDVzR2R2ZNVnJzdFFFcXhMSkM5TFhzSGJXSUp4b1VTNlpiTjRPVWl2WlVTNE8KWGlKTlFSQW5GZnY3Qkw5SXR5NWxucS9CZTBPMFlBQkhoeGZOQ0FHOFRjd0cxVUxWMlRGMlZXVi9LQVAvODFiUQpWNmxrZlVnNTNZQmpTRVN1WkRRbmZibkJrMDFjd3FmUzZyZFV3dW44U3BjbHBQMFlFbWIyTUpEZmF6bll3RkdBCldQNnRiSzhTTXhiMlJnOUR1VWdrMEZBb1NFcDlvc25NQVF2eEMzZmx2Mzd4b0VYZTBDYXdjVEFwOEo2S1J2QlAKcmp2eDVUWkZrU2xjV2RCTktVZEN0QT09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K", + "service": { + "name": "kubernetes", + "namespace": "default", + "path": "/apis/webhook.cert-manager.io/v1beta1/mutations", + "port": 443 + } + }, + "failurePolicy": "Fail", + "matchPolicy": "Exact", + "name": "webhook.cert-manager.io", + "namespaceSelector": {}, + "objectSelector": {}, + "reinvocationPolicy": "Never", + "rules": [ + { + "apiGroups": [ + "cert-manager.io" + ], + "apiVersions": [ + "v1alpha2" + ], + "operations": [ + "CREATE", + "UPDATE" + ], + "resources": [ + "certificates", + "issuers", + "clusterissuers", + "orders", + "challenges", + "certificaterequests" + ], + "scope": "*" + } + ], + "sideEffects": "Unknown", + "timeoutSeconds": 30 + } + ] +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/openapiv2.bin b/gitops-engine/pkg/diff/testdata/openapiv2.bin new file mode 100644 index 0000000000000..d85718c13a774 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/openapiv2.bin @@ -0,0 +1,72907 @@ + +2.0 + +Kubernetesv1.24.0B +"/.well-known/openid-configuration/ + WellKnownWget service account issuer OpenID configuration, also known as the 'OIDC discovery doc'**getServiceAccountIssuerOpenIDConfiguration2application/jsonJ7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttps +/api/ +coreget available API versions*getCoreAPIVersions2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJl +Q +200J +H +OKB +@ +>#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions + +401 + + UnauthorizedRhttps +/api/v1/ +core_v1get available resources*getCoreV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +/api/v1/componentstatuses% +core_v1$list objects of kind ComponentStatus*listCoreV1ComponentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.core.v1.ComponentStatusList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jQ +x-kubernetes-group-version-kind.,group: "" +kind: ComponentStatus +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean + /api/v1/componentstatuses/{name} +core_v1"read the specified ComponentStatus*readCoreV1ComponentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.core.v1.ComponentStatus + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jQ +x-kubernetes-group-version-kind.,group: "" +kind: ComponentStatus +version: v1 +J< +:8"6pathname of the ComponentStatus"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +/api/v1/configmaps% +core_v1'list or watch objects of kind ConfigMap*#listCoreV1ConfigMapForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ConfigMapList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/endpoints% +core_v1'list or watch objects of kind Endpoints*#listCoreV1EndpointsForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.EndpointsList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/events% +core_v1#list or watch objects of kind Event*listCoreV1EventForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/limitranges& +core_v1(list or watch objects of kind LimitRange*$listCoreV1LimitRangeForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.LimitRangeList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean. +/api/v1/namespaces.% +core_v1'list or watch objects of kind Namespace*listCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.NamespaceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +" +core_v1create a Namespace*createCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.NamespaceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace +C +202< +: +Accepted. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string + +'/api/v1/namespaces/{namespace}/bindings +" +core_v1create a Binding*createCoreV1NamespacedBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.core.v1.BindingJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Binding +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Binding +A +202: +8 +Accepted, +* +(#/definitions/io.k8s.api.core.v1.Binding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jI +x-kubernetes-group-version-kind&$group: "" +kind: Binding +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +)/api/v1/namespaces/{namespace}/configmaps\% +core_v1'list or watch objects of kind ConfigMap*listCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ConfigMapList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +" +core_v1create a ConfigMap*createCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.ConfigMapB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap +C +202< +: +Accepted. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +*, +core_v1delete collection of ConfigMap*)deleteCoreV1CollectionNamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +0/api/v1/namespaces/{namespace}/configmaps/{name}) +core_v1read the specified ConfigMap*readCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 + +core_v1replace the specified ConfigMap* replaceCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.ConfigMapB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +* +core_v1delete a ConfigMap*deleteCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +B +core_v1(partially update the specified ConfigMap*patchCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J6 +42"0pathname of the ConfigMap"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +(/api/v1/namespaces/{namespace}/endpoints\% +core_v1'list or watch objects of kind Endpoints*listCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.EndpointsList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +" +core_v1create Endpoints*createCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.EndpointsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Endpoints +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Endpoints +C +202< +: +Accepted. +, +*#/definitions/io.k8s.api.core.v1.Endpoints + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +*, +core_v1delete collection of Endpoints*)deleteCoreV1CollectionNamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +//api/v1/namespaces/{namespace}/endpoints/{name}) +core_v1read the specified Endpoints*readCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Endpoints + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 + +core_v1replace the specified Endpoints* replaceCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.EndpointsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Endpoints +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Endpoints + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +* +core_v1delete Endpoints*deleteCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +B +core_v1(partially update the specified Endpoints*patchCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Endpoints +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Endpoints + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J6 +42"0pathname of the Endpoints"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string[ +%/api/v1/namespaces/{namespace}/events[% +core_v1#list or watch objects of kind Event*listCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +" +core_v1create an Event*createCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B< +: +8bodybody *( +&#/definitions/io.k8s.api.core.v1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +9 +2002 +0 +OK* +( +&#/definitions/io.k8s.api.core.v1.Event +> +2017 +5 +Created* +( +&#/definitions/io.k8s.api.core.v1.Event +? +2028 +6 +Accepted* +( +&#/definitions/io.k8s.api.core.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +*, +core_v1delete collection of Event*%deleteCoreV1CollectionNamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +,/api/v1/namespaces/{namespace}/events/{name}( +core_v1read the specified Event*readCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JT +9 +2002 +0 +OK* +( +&#/definitions/io.k8s.api.core.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 + +core_v1replace the specified Event*replaceCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B< +: +8bodybody *( +&#/definitions/io.k8s.api.core.v1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +9 +2002 +0 +OK* +( +&#/definitions/io.k8s.api.core.v1.Event +> +2017 +5 +Created* +( +&#/definitions/io.k8s.api.core.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +* +core_v1delete an Event*deleteCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +B +core_v1$partially update the specified Event*patchCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +9 +2002 +0 +OK* +( +&#/definitions/io.k8s.api.core.v1.Event +> +2017 +5 +Created* +( +&#/definitions/io.k8s.api.core.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +*/api/v1/namespaces/{namespace}/limitranges\% +core_v1(list or watch objects of kind LimitRange*listCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.LimitRangeList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +" +core_v1create a LimitRange* createCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.core.v1.LimitRangeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +*, +core_v1delete collection of LimitRange**deleteCoreV1CollectionNamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +1/api/v1/namespaces/{namespace}/limitranges/{name}) +core_v1read the specified LimitRange*readCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 + +core_v1 replace the specified LimitRange*!replaceCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.core.v1.LimitRangeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +* +core_v1delete a LimitRange* deleteCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +B +core_v1)partially update the specified LimitRange*patchCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J7 +53"1pathname of the LimitRange"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string] +5/api/v1/namespaces/{namespace}/persistentvolumeclaims]% +core_v13list or watch objects of kind PersistentVolumeClaim*)listCoreV1NamespacedPersistentVolumeClaim2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +" +core_v1create a PersistentVolumeClaim*+createCoreV1NamespacedPersistentVolumeClaim2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim +O +202H +F +Accepted: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +*, +core_v1*delete collection of PersistentVolumeClaim*5deleteCoreV1CollectionNamespacedPersistentVolumeClaim2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +"<path!name of the PersistentVolumeClaim"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +C/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status +core_v12read status of the specified PersistentVolumeClaim*/readCoreV1NamespacedPersistentVolumeClaimStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 + +core_v15replace status of the specified PersistentVolumeClaim*2replaceCoreV1NamespacedPersistentVolumeClaimStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +B +core_v1>partially update status of the specified PersistentVolumeClaim*0patchCoreV1NamespacedPersistentVolumeClaimStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +JB +@>"<path!name of the PersistentVolumeClaim"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string[ +#/api/v1/namespaces/{namespace}/pods[% +core_v1!list or watch objects of kind Pod*listCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJV +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.PodList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +" +core_v1 create a Pod*createCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B: +8 +6bodybody *& +$#/definitions/io.k8s.api.core.v1.PodB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod += +2026 +4 +Accepted( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +*, +core_v1delete collection of Pod*#deleteCoreV1CollectionNamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string( +*/api/v1/namespaces/{namespace}/pods/{name}( +core_v1read the specified Pod*readCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JR +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 + +core_v1replace the specified Pod*replaceCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B: +8 +6bodybody *& +$#/definitions/io.k8s.api.core.v1.PodB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +* +core_v1 delete a Pod*deleteCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod += +2026 +4 +Accepted( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +B +core_v1"partially update the specified Pod*patchCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J0 +.,"*pathname of the Pod"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +1/api/v1/namespaces/{namespace}/pods/{name}/attach  +core_v1%connect GET requests to attach of Pod*#connectCoreV1GetNamespacedPodAttach2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: PodAttachOptions +version: v1 +" +core_v1&connect POST requests to attach of Pod*$connectCoreV1PostNamespacedPodAttach2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: PodAttachOptions +version: v1 +J +querytThe container in which to execute the command. Defaults to only container if there is only one container in the pod." container2stringJ= +;9"7pathname of the PodAttachOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJ +~|query_Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true."stderr2booleanJ +}{query_Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false."stdin2booleanJ +~|query_Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true."stdout2booleanJ +queryTTY if true indicates that a tty will be allocated for the attach call. This is passed through the container runtime so the tty is allocated on the worker node by the container runtime. Defaults to false."tty2boolean + +2/api/v1/namespaces/{namespace}/pods/{name}/binding +" +core_v1create binding of a Pod* createCoreV1NamespacedPodBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.core.v1.BindingJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Binding +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Binding +A +202: +8 +Accepted, +* +(#/definitions/io.k8s.api.core.v1.Binding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jI +x-kubernetes-group-version-kind&$group: "" +kind: Binding +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ4 +20".pathname of the Binding"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +>/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers +core_v1-read ephemeralcontainers of the specified Pod**readCoreV1NamespacedPodEphemeralcontainers2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JR +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 + +core_v10replace ephemeralcontainers of the specified Pod*-replaceCoreV1NamespacedPodEphemeralcontainers2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B: +8 +6bodybody *& +$#/definitions/io.k8s.api.core.v1.PodB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +B +core_v19partially update ephemeralcontainers of the specified Pod*+patchCoreV1NamespacedPodEphemeralcontainers2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J0 +.,"*pathname of the Pod"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +3/api/v1/namespaces/{namespace}/pods/{name}/eviction +" +core_v1create eviction of a Pod*!createCoreV1NamespacedPodEviction2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.policy.v1.EvictionJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.policy.v1.Eviction +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.policy.v1.Eviction +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.policy.v1.Eviction + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jN +x-kubernetes-group-version-kind+)group: policy +kind: Eviction +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ5 +31"/pathname of the Eviction"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +//api/v1/namespaces/{namespace}/pods/{name}/exec  +core_v1#connect GET requests to exec of Pod*!connectCoreV1GetNamespacedPodExec2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jP +x-kubernetes-group-version-kind-+group: "" +kind: PodExecOptions +version: v1 +" +core_v1$connect POST requests to exec of Pod*"connectCoreV1PostNamespacedPodExec2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jP +x-kubernetes-group-version-kind-+group: "" +kind: PodExecOptions +version: v1 +Ju +sqoqueryRCommand is the remote command to execute. argv array. Not executed within a shell."command2stringJ +querypContainer in which to execute the command. Defaults to only container if there is only one container in the pod." container2stringJ; +97"5pathname of the PodExecOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJ_ +][Yquery"<path!name of the PodPortForwardOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJY +WUSquery7List of ports to forward Required when using WebSockets"ports2integer +0/api/v1/namespaces/{namespace}/pods/{name}/proxy +core_v1$connect GET requests to proxy of Pod*"connectCoreV1GetNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 + +core_v1$connect PUT requests to proxy of Pod*"connectCoreV1PutNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +" +core_v1%connect POST requests to proxy of Pod*#connectCoreV1PostNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +* +core_v1'connect DELETE requests to proxy of Pod*%connectCoreV1DeleteNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +2 +core_v1(connect OPTIONS requests to proxy of Pod*&connectCoreV1OptionsNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +: +core_v1%connect HEAD requests to proxy of Pod*#connectCoreV1HeadNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +B +core_v1&connect PATCH requests to proxy of Pod*$connectCoreV1PatchNamespacedPodProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +J< +:8"6pathname of the PodProxyOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJa +_][queryAPath is the URL path to use for the current proxy request to pod."path2string +7/api/v1/namespaces/{namespace}/pods/{name}/proxy/{path} +core_v1$connect GET requests to proxy of Pod**connectCoreV1GetNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 + +core_v1$connect PUT requests to proxy of Pod**connectCoreV1PutNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +" +core_v1%connect POST requests to proxy of Pod*+connectCoreV1PostNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +* +core_v1'connect DELETE requests to proxy of Pod*-connectCoreV1DeleteNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +2 +core_v1(connect OPTIONS requests to proxy of Pod*.connectCoreV1OptionsNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +: +core_v1%connect HEAD requests to proxy of Pod*+connectCoreV1HeadNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +B +core_v1&connect PATCH requests to proxy of Pod*,connectCoreV1PatchNamespacedPodProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jQ +x-kubernetes-group-version-kind.,group: "" +kind: PodProxyOptions +version: v1 +J< +:8"6pathname of the PodProxyOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJ5 +31"/pathpath to the resource"path*stringJa +_][queryAPath is the URL path to use for the current proxy request to pod."path2string +1/api/v1/namespaces/{namespace}/pods/{name}/status +core_v1 read status of the specified Pod*readCoreV1NamespacedPodStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JR +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 + +core_v1#replace status of the specified Pod* replaceCoreV1NamespacedPodStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B: +8 +6bodybody *& +$#/definitions/io.k8s.api.core.v1.PodB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +B +core_v1,partially update status of the specified Pod*patchCoreV1NamespacedPodStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +7 +2000 +. +OK( +& +$#/definitions/io.k8s.api.core.v1.Pod +< +2015 +3 +Created( +& +$#/definitions/io.k8s.api.core.v1.Pod + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J0 +.,"*pathname of the Pod"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ ++/api/v1/namespaces/{namespace}/podtemplates\% +core_v1)list or watch objects of kind PodTemplate*listCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.core.v1.PodTemplateList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +" +core_v1create a PodTemplate*!createCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.core.v1.PodTemplateB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate +E +202> +< +Accepted0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +*, +core_v1 delete collection of PodTemplate*+deleteCoreV1CollectionNamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +2/api/v1/namespaces/{namespace}/podtemplates/{name}) +core_v1read the specified PodTemplate*readCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 + +core_v1!replace the specified PodTemplate*"replaceCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.core.v1.PodTemplateB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +* +core_v1delete a PodTemplate*!deleteCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate +E +202> +< +Accepted0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +B +core_v1*partially update the specified PodTemplate* patchCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J8 +64"2pathname of the PodTemplate"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string] +5/api/v1/namespaces/{namespace}/replicationcontrollers]% +core_v13list or watch objects of kind ReplicationController*)listCoreV1NamespacedReplicationController2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.core.v1.ReplicationControllerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +" +core_v1create a ReplicationController*+createCoreV1NamespacedReplicationController2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.core.v1.ReplicationControllerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController +O +202H +F +Accepted: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +*, +core_v1*delete collection of ReplicationController*5deleteCoreV1CollectionNamespacedReplicationController2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +"<path!name of the ReplicationController"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +B/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale +core_v11read scale of the specified ReplicationController*.readCoreV1NamespacedReplicationControllerScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 + +core_v14replace scale of the specified ReplicationController*1replaceCoreV1NamespacedReplicationControllerScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.autoscaling.v1.ScaleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +B +core_v1=partially update scale of the specified ReplicationController*/patchCoreV1NamespacedReplicationControllerScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +J2 +0.",pathname of the Scale"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +C/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status +core_v12read status of the specified ReplicationController*/readCoreV1NamespacedReplicationControllerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 + +core_v15replace status of the specified ReplicationController*2replaceCoreV1NamespacedReplicationControllerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.core.v1.ReplicationControllerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +B +core_v1>partially update status of the specified ReplicationController*0patchCoreV1NamespacedReplicationControllerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +JB +@>"<path!name of the ReplicationController"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +-/api/v1/namespaces/{namespace}/resourcequotas\% +core_v1+list or watch objects of kind ResourceQuota*!listCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.core.v1.ResourceQuotaList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +" +core_v1create a ResourceQuota*#createCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.core.v1.ResourceQuotaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +G +202@ +> +Accepted2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +*, +core_v1"delete collection of ResourceQuota*-deleteCoreV1CollectionNamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +4/api/v1/namespaces/{namespace}/resourcequotas/{name}) +core_v1 read the specified ResourceQuota*!readCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 + +core_v1#replace the specified ResourceQuota*$replaceCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.core.v1.ResourceQuotaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +* +core_v1delete a ResourceQuota*#deleteCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +G +202@ +> +Accepted2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +B +core_v1,partially update the specified ResourceQuota*"patchCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J: +86"4pathname of the ResourceQuota"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +;/api/v1/namespaces/{namespace}/resourcequotas/{name}/status +core_v1*read status of the specified ResourceQuota*'readCoreV1NamespacedResourceQuotaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 + +core_v1-replace status of the specified ResourceQuota**replaceCoreV1NamespacedResourceQuotaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.core.v1.ResourceQuotaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +B +core_v16partially update status of the specified ResourceQuota*(patchCoreV1NamespacedResourceQuotaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J: +86"4pathname of the ResourceQuota"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +&/api/v1/namespaces/{namespace}/secrets[% +core_v1$list or watch objects of kind Secret*listCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.SecretList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +" +core_v1create a Secret*createCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B= +; +9bodybody *) +'#/definitions/io.k8s.api.core.v1.SecretB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +: +2003 +1 +OK+ +) +'#/definitions/io.k8s.api.core.v1.Secret +? +2018 +6 +Created+ +) +'#/definitions/io.k8s.api.core.v1.Secret +@ +2029 +7 +Accepted+ +) +'#/definitions/io.k8s.api.core.v1.Secret + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +*, +core_v1delete collection of Secret*&deleteCoreV1CollectionNamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +-/api/v1/namespaces/{namespace}/secrets/{name}( +core_v1read the specified Secret*readCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JU +: +2003 +1 +OK+ +) +'#/definitions/io.k8s.api.core.v1.Secret + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 + +core_v1replace the specified Secret*replaceCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B= +; +9bodybody *) +'#/definitions/io.k8s.api.core.v1.SecretB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +: +2003 +1 +OK+ +) +'#/definitions/io.k8s.api.core.v1.Secret +? +2018 +6 +Created+ +) +'#/definitions/io.k8s.api.core.v1.Secret + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +* +core_v1delete a Secret*deleteCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +B +core_v1%partially update the specified Secret*patchCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +: +2003 +1 +OK+ +) +'#/definitions/io.k8s.api.core.v1.Secret +? +2018 +6 +Created+ +) +'#/definitions/io.k8s.api.core.v1.Secret + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J3 +1/"-pathname of the Secret"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +./api/v1/namespaces/{namespace}/serviceaccounts\% +core_v1,list or watch objects of kind ServiceAccount*"listCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJa +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.core.v1.ServiceAccountList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +" +core_v1create a ServiceAccount*$createCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BE +C +Abodybody *1 +/#/definitions/io.k8s.api.core.v1.ServiceAccountB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount +G +201@ +> +Created3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount +H +202A +? +Accepted3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +*, +core_v1#delete collection of ServiceAccount*.deleteCoreV1CollectionNamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +5/api/v1/namespaces/{namespace}/serviceaccounts/{name}) +core_v1!read the specified ServiceAccount*"readCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 + +core_v1$replace the specified ServiceAccount*%replaceCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BE +C +Abodybody *1 +/#/definitions/io.k8s.api.core.v1.ServiceAccountB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount +G +201@ +> +Created3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +* +core_v1delete a ServiceAccount*$deleteCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount +H +202A +? +Accepted3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +B +core_v1-partially update the specified ServiceAccount*#patchCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount +G +201@ +> +Created3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J; +97"5pathname of the ServiceAccount"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +;/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token " +core_v1 create token of a ServiceAccount*)createCoreV1NamespacedServiceAccountToken2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.authentication.v1.TokenRequestJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.authentication.v1.TokenRequest +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.authentication.v1.TokenRequest +P +202I +G +Accepted; +9 +7#/definitions/io.k8s.api.authentication.v1.TokenRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +ja +x-kubernetes-group-version-kind> +< +:bodybody ** +(#/definitions/io.k8s.api.core.v1.ServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Service +A +202: +8 +Accepted, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +*, +core_v1delete collection of Service*'deleteCoreV1CollectionNamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +./api/v1/namespaces/{namespace}/services/{name}( +core_v1read the specified Service*readCoreV1NamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JV +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 + +core_v1replace the specified Service*replaceCoreV1NamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.core.v1.ServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +* +core_v1delete a Service*deleteCoreV1NamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +A +202: +8 +Accepted, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +B +core_v1&partially update the specified Service*patchCoreV1NamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J4 +20".pathname of the Service"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +4/api/v1/namespaces/{namespace}/services/{name}/proxy +core_v1(connect GET requests to proxy of Service*&connectCoreV1GetNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 + +core_v1(connect PUT requests to proxy of Service*&connectCoreV1PutNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +" +core_v1)connect POST requests to proxy of Service*'connectCoreV1PostNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +* +core_v1+connect DELETE requests to proxy of Service*)connectCoreV1DeleteNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +2 +core_v1,connect OPTIONS requests to proxy of Service**connectCoreV1OptionsNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +: +core_v1)connect HEAD requests to proxy of Service*'connectCoreV1HeadNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +B +core_v1*connect PATCH requests to proxy of Service*(connectCoreV1PatchNamespacedServiceProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +J@ +><":pathname of the ServiceProxyOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJ +queryPath is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy."path2string +;/api/v1/namespaces/{namespace}/services/{name}/proxy/{path} +core_v1(connect GET requests to proxy of Service*.connectCoreV1GetNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 + +core_v1(connect PUT requests to proxy of Service*.connectCoreV1PutNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +" +core_v1)connect POST requests to proxy of Service*/connectCoreV1PostNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +* +core_v1+connect DELETE requests to proxy of Service*1connectCoreV1DeleteNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +2 +core_v1,connect OPTIONS requests to proxy of Service*2connectCoreV1OptionsNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +: +core_v1)connect HEAD requests to proxy of Service*/connectCoreV1HeadNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +B +core_v1*connect PATCH requests to proxy of Service*0connectCoreV1PatchNamespacedServiceProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jU +x-kubernetes-group-version-kind20group: "" +kind: ServiceProxyOptions +version: v1 +J@ +><":pathname of the ServiceProxyOptions"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJ5 +31"/pathpath to the resource"path*stringJ +queryPath is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy."path2string +5/api/v1/namespaces/{namespace}/services/{name}/status +core_v1$read status of the specified Service*!readCoreV1NamespacedServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JV +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 + +core_v1'replace status of the specified Service*$replaceCoreV1NamespacedServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.core.v1.ServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +B +core_v10partially update status of the specified Service*"patchCoreV1NamespacedServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.Service +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.core.v1.Service + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J4 +20".pathname of the Service"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string( +/api/v1/namespaces/{name}( +core_v1read the specified Namespace*readCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 + +core_v1replace the specified Namespace*replaceCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.NamespaceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +* +core_v1delete a Namespace*deleteCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +B +core_v1(partially update the specified Namespace*patchCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +J6 +42"0pathname of the Namespace"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +"/api/v1/namespaces/{name}/finalize  +core_v1+replace finalize of the specified Namespace*replaceCoreV1NamespaceFinalize2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.NamespaceJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ6 +42"0pathname of the Namespace"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string + /api/v1/namespaces/{name}/status +core_v1&read status of the specified Namespace*readCoreV1NamespaceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 + +core_v1)replace status of the specified Namespace*replaceCoreV1NamespaceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.core.v1.NamespaceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +B +core_v12partially update status of the specified Namespace*patchCoreV1NamespaceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.core.v1.Namespace +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.core.v1.Namespace + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +J6 +42"0pathname of the Namespace"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringZ + /api/v1/nodesZ% +core_v1"list or watch objects of kind Node*listCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJW +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.core.v1.NodeList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +" +core_v1 create a Node*createCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.core.v1.NodeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.core.v1.Node +> +2027 +5 +Accepted) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +*, +core_v1delete collection of Node*deleteCoreV1CollectionNode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +/api/v1/nodes/{name}' +core_v1read the specified Node*readCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JS +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 + +core_v1replace the specified Node*replaceCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.core.v1.NodeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +* +core_v1 delete a Node*deleteCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +B +core_v1#partially update the specified Node*patchCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +J1 +/-"+pathname of the Node"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +/api/v1/nodes/{name}/proxy +core_v1%connect GET requests to proxy of Node*connectCoreV1GetNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 + +core_v1%connect PUT requests to proxy of Node*connectCoreV1PutNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +" +core_v1&connect POST requests to proxy of Node*connectCoreV1PostNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +* +core_v1(connect DELETE requests to proxy of Node*connectCoreV1DeleteNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +2 +core_v1)connect OPTIONS requests to proxy of Node*connectCoreV1OptionsNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +: +core_v1&connect HEAD requests to proxy of Node*connectCoreV1HeadNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +B +core_v1'connect PATCH requests to proxy of Node*connectCoreV1PatchNodeProxy2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +J= +;9"7pathname of the NodeProxyOptions"name*stringJb +`^\queryBPath is the URL path to use for the current proxy request to node."path2string +!/api/v1/nodes/{name}/proxy/{path} +core_v1%connect GET requests to proxy of Node*!connectCoreV1GetNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 + +core_v1%connect PUT requests to proxy of Node*!connectCoreV1PutNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +" +core_v1&connect POST requests to proxy of Node*"connectCoreV1PostNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +* +core_v1(connect DELETE requests to proxy of Node*$connectCoreV1DeleteNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +2 +core_v1)connect OPTIONS requests to proxy of Node*%connectCoreV1OptionsNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +: +core_v1&connect HEAD requests to proxy of Node*"connectCoreV1HeadNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +B +core_v1'connect PATCH requests to proxy of Node*#connectCoreV1PatchNodeProxyWithPath2*/*:*/*J7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttpsj! +x-kubernetes-action +connect +jR +x-kubernetes-group-version-kind/-group: "" +kind: NodeProxyOptions +version: v1 +J= +;9"7pathname of the NodeProxyOptions"name*stringJ5 +31"/pathpath to the resource"path*stringJb +`^\queryBPath is the URL path to use for the current proxy request to node."path2string +/api/v1/nodes/{name}/status +core_v1!read status of the specified Node*readCoreV1NodeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JS +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 + +core_v1$replace status of the specified Node*replaceCoreV1NodeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.core.v1.NodeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +B +core_v1-partially update status of the specified Node*patchCoreV1NodeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.core.v1.Node += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.core.v1.Node + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +J1 +/-"+pathname of the Node"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +/api/v1/persistentvolumeclaims& +core_v13list or watch objects of kind PersistentVolumeClaim*/listCoreV1PersistentVolumeClaimForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean\ +/api/v1/persistentvolumes[% +core_v1.list or watch objects of kind PersistentVolume*listCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJc +H +200A +? +OK9 +7 +5#/definitions/io.k8s.api.core.v1.PersistentVolumeList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +" +core_v1create a PersistentVolume*createCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BG +E +Cbodybody *3 +1#/definitions/io.k8s.api.core.v1.PersistentVolumeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +I +201B +@ +Created5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +J +202C +A +Accepted5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +*, +core_v1%delete collection of PersistentVolume*&deleteCoreV1CollectionPersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string) + /api/v1/persistentvolumes/{name}) +core_v1#read the specified PersistentVolume*readCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 + +core_v1&replace the specified PersistentVolume*replaceCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BG +E +Cbodybody *3 +1#/definitions/io.k8s.api.core.v1.PersistentVolumeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +I +201B +@ +Created5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +* +core_v1delete a PersistentVolume*deleteCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +J +202C +A +Accepted5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +B +core_v1/partially update the specified PersistentVolume*patchCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +I +201B +@ +Created5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +J= +;9"7pathname of the PersistentVolume"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +'/api/v1/persistentvolumes/{name}/status +core_v1-read status of the specified PersistentVolume* readCoreV1PersistentVolumeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 + +core_v10replace status of the specified PersistentVolume*#replaceCoreV1PersistentVolumeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BG +E +Cbodybody *3 +1#/definitions/io.k8s.api.core.v1.PersistentVolumeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +I +201B +@ +Created5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +B +core_v19partially update status of the specified PersistentVolume*!patchCoreV1PersistentVolumeStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume +I +201B +@ +Created5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +J= +;9"7pathname of the PersistentVolume"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string% + /api/v1/pods% +core_v1!list or watch objects of kind Pod*listCoreV1PodForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JV +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.core.v1.PodList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/podtemplates& +core_v1)list or watch objects of kind PodTemplate*%listCoreV1PodTemplateForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.core.v1.PodTemplateList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/replicationcontrollers& +core_v13list or watch objects of kind ReplicationController*/listCoreV1ReplicationControllerForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.core.v1.ReplicationControllerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/resourcequotas& +core_v1+list or watch objects of kind ResourceQuota*'listCoreV1ResourceQuotaForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.core.v1.ResourceQuotaList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/secrets% +core_v1$list or watch objects of kind Secret* listCoreV1SecretForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.core.v1.SecretList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/serviceaccounts& +core_v1,list or watch objects of kind ServiceAccount*(listCoreV1ServiceAccountForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Ja +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.core.v1.ServiceAccountList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/services% +core_v1%list or watch objects of kind Service*!listCoreV1ServiceForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.core.v1.ServiceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/configmaps& +core_v1uwatch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.*(watchCoreV1ConfigMapListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/endpoints& +core_v1uwatch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.*(watchCoreV1EndpointsListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/events& +core_v1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.*$watchCoreV1EventListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/limitranges& +core_v1vwatch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.*)watchCoreV1LimitRangeListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/namespaces& +core_v1uwatch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1NamespaceList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +//api/v1/watch/namespaces/{namespace}/configmaps' +core_v1uwatch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.*"watchCoreV1NamespacedConfigMapList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +6/api/v1/watch/namespaces/{namespace}/configmaps/{name}( +core_v1watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedConfigMap2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: ConfigMap +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ6 +42"0pathname of the ConfigMap"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +./api/v1/watch/namespaces/{namespace}/endpoints' +core_v1uwatch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.*"watchCoreV1NamespacedEndpointsList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +5/api/v1/watch/namespaces/{namespace}/endpoints/{name}( +core_v1watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedEndpoints2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: Endpoints +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ6 +42"0pathname of the Endpoints"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' ++/api/v1/watch/namespaces/{namespace}/events' +core_v1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1NamespacedEventList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +2/api/v1/watch/namespaces/{namespace}/events/{name}( +core_v1watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jG +x-kubernetes-group-version-kind$"group: "" +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +0/api/v1/watch/namespaces/{namespace}/limitranges' +core_v1vwatch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.*#watchCoreV1NamespacedLimitRangeList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +7/api/v1/watch/namespaces/{namespace}/limitranges/{name}( +core_v1watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedLimitRange2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jL +x-kubernetes-group-version-kind)'group: "" +kind: LimitRange +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ7 +53"1pathname of the LimitRange"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +;/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims' +core_v1watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.*.watchCoreV1NamespacedPersistentVolumeClaimList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +B/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}( +core_v1watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.**watchCoreV1NamespacedPersistentVolumeClaim2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJB +@>"<path!name of the PersistentVolumeClaim"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +)/api/v1/watch/namespaces/{namespace}/pods' +core_v1owatch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1NamespacedPodList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +0/api/v1/watch/namespaces/{namespace}/pods/{name}( +core_v1watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedPod2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ0 +.,"*pathname of the Pod"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +1/api/v1/watch/namespaces/{namespace}/podtemplates' +core_v1wwatch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.*$watchCoreV1NamespacedPodTemplateList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +8/api/v1/watch/namespaces/{namespace}/podtemplates/{name}( +core_v1watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.* watchCoreV1NamespacedPodTemplate2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ8 +64"2pathname of the PodTemplate"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +;/api/v1/watch/namespaces/{namespace}/replicationcontrollers' +core_v1watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.*.watchCoreV1NamespacedReplicationControllerList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +B/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}( +core_v1watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.**watchCoreV1NamespacedReplicationController2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJB +@>"<path!name of the ReplicationController"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +3/api/v1/watch/namespaces/{namespace}/resourcequotas' +core_v1ywatch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.*&watchCoreV1NamespacedResourceQuotaList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +:/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}( +core_v1watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*"watchCoreV1NamespacedResourceQuota2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ: +86"4pathname of the ResourceQuota"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +,/api/v1/watch/namespaces/{namespace}/secrets' +core_v1rwatch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1NamespacedSecretList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +3/api/v1/watch/namespaces/{namespace}/secrets/{name}( +core_v1watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedSecret2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ3 +1/"-pathname of the Secret"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +4/api/v1/watch/namespaces/{namespace}/serviceaccounts' +core_v1zwatch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.*'watchCoreV1NamespacedServiceAccountList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +;/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}( +core_v1watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*#watchCoreV1NamespacedServiceAccount2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ; +97"5pathname of the ServiceAccount"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +-/api/v1/watch/namespaces/{namespace}/services' +core_v1swatch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.* watchCoreV1NamespacedServiceList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +4/api/v1/watch/namespaces/{namespace}/services/{name}( +core_v1watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1NamespacedService2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ4 +20".pathname of the Service"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/namespaces/{name}' +core_v1watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1Namespace2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jK +x-kubernetes-group-version-kind(&group: "" +kind: Namespace +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ6 +42"0pathname of the Namespace"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/nodes& +core_v1pwatch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1NodeList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/nodes/{name}' +core_v1watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1Node2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jF +x-kubernetes-group-version-kind#!group: "" +kind: Node +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ1 +/-"+pathname of the Node"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +$/api/v1/watch/persistentvolumeclaims' +core_v1watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.*4watchCoreV1PersistentVolumeClaimListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: "" +kind: PersistentVolumeClaim +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/persistentvolumes& +core_v1|watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.*watchCoreV1PersistentVolumeList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +&/api/v1/watch/persistentvolumes/{name}' +core_v1watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchCoreV1PersistentVolume2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jR +x-kubernetes-group-version-kind/-group: "" +kind: PersistentVolume +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ= +;9"7pathname of the PersistentVolume"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/pods& +core_v1owatch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.*"watchCoreV1PodListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jE +x-kubernetes-group-version-kind" group: "" +kind: Pod +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/podtemplates& +core_v1wwatch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.**watchCoreV1PodTemplateListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jM +x-kubernetes-group-version-kind*(group: "" +kind: PodTemplate +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +$/api/v1/watch/replicationcontrollers' +core_v1watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.*4watchCoreV1ReplicationControllerListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: "" +kind: ReplicationController +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/resourcequotas& +core_v1ywatch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.*,watchCoreV1ResourceQuotaListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jO +x-kubernetes-group-version-kind,*group: "" +kind: ResourceQuota +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/secrets& +core_v1rwatch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.*%watchCoreV1SecretListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jH +x-kubernetes-group-version-kind%#group: "" +kind: Secret +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/api/v1/watch/serviceaccounts& +core_v1zwatch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.*-watchCoreV1ServiceAccountListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jP +x-kubernetes-group-version-kind-+group: "" +kind: ServiceAccount +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/api/v1/watch/services& +core_v1swatch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.*&watchCoreV1ServiceListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jI +x-kubernetes-group-version-kind&$group: "" +kind: Service +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/ +apisget available API versions*getAPIVersions2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJm +R +200K +I +OKC +A +?#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroupList + +401 + + UnauthorizedRhttpsW +N/apis/actions.summerwind.dev/v1alpha1/namespaces/{namespace}/runnerdeploymentsV% +actionsSummerwindDev_v1alpha1%list objects of kind RunnerDeployment*:listActionsSummerwindDevV1alpha1NamespacedRunnerDeployment2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJp +U +200N +L +OKF +D +B#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeploymentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +" + +actionsSummerwindDev_v1alpha1create a RunnerDeployment*#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment +V +201O +M +CreatedB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment +W +202P +N +AcceptedB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +*% +actionsSummerwindDev_v1alpha1%delete collection of RunnerDeployment*FdeleteActionsSummerwindDevV1alpha1CollectionNamespacedRunnerDeployment2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +U/apis/actions.summerwind.dev/v1alpha1/namespaces/{namespace}/runnerdeployments/{name}* +actionsSummerwindDev_v1alpha1#read the specified RunnerDeployment*:readActionsSummerwindDevV1alpha1NamespacedRunnerDeployment2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJl +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 + +actionsSummerwindDev_v1alpha1&replace the specified RunnerDeployment*=replaceActionsSummerwindDevV1alpha1NamespacedRunnerDeployment2application/json2application/yaml:application/json:application/yamlBT +R +Pbodybody *@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment +V +201O +M +CreatedB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +* +actionsSummerwindDev_v1alpha1delete a RunnerDeployment* +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +B +actionsSummerwindDev_v1alpha1/partially update the specified RunnerDeployment*;patchActionsSummerwindDevV1alpha1NamespacedRunnerDeployment2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJl +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +J= +;9"7pathname of the RunnerDeployment"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +\/apis/actions.summerwind.dev/v1alpha1/namespaces/{namespace}/runnerdeployments/{name}/status +actionsSummerwindDev_v1alpha1-read status of the specified RunnerDeployment*@readActionsSummerwindDevV1alpha1NamespacedRunnerDeploymentStatus2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJl +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 + +actionsSummerwindDev_v1alpha10replace status of the specified RunnerDeployment*CreplaceActionsSummerwindDevV1alpha1NamespacedRunnerDeploymentStatus2application/json2application/yaml:application/json:application/yamlBT +R +Pbodybody *@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment +V +201O +M +CreatedB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +B +actionsSummerwindDev_v1alpha19partially update status of the specified RunnerDeployment*ApatchActionsSummerwindDevV1alpha1NamespacedRunnerDeploymentStatus2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJl +Q +200J +H +OKB +@ +>#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +J= +;9"7pathname of the RunnerDeployment"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +7/apis/actions.summerwind.dev/v1alpha1/runnerdeployments& +actionsSummerwindDev_v1alpha1%list objects of kind RunnerDeployment*@listActionsSummerwindDevV1alpha1RunnerDeploymentForAllNamespaces2application/json2application/yaml:application/json:application/yamlJp +U +200N +L +OKF +D +B#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeploymentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: actions.summerwind.dev +kind: RunnerDeployment +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +#/apis/admissionregistration.k8s.io/ +admissionregistrationget information of a group* getAdmissionregistrationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +&/apis/admissionregistration.k8s.io/v1/ +admissionregistration_v1get available resources*&getAdmissionregistrationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps_ +C/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations_& +admissionregistration_v1:list or watch objects of kind MutatingWebhookConfiguration*7listAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ +e +200^ +\ +OKV +T +R#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfigurationList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +" + +admissionregistration_v1%create a MutatingWebhookConfiguration*9createAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Bd +b +`bodybody *P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfigurationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +a +200Z +X +OKR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration +f +201_ +] +CreatedR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration +g +202` +^ +AcceptedR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +*- +admissionregistration_v11delete collection of MutatingWebhookConfiguration*CdeleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string. +J/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/{name}- +admissionregistration_v1/read the specified MutatingWebhookConfiguration*7readAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J| +a +200Z +X +OKR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 + +admissionregistration_v12replace the specified MutatingWebhookConfiguration*:replaceAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Bd +b +`bodybody *P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfigurationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +a +200Z +X +OKR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration +f +201_ +] +CreatedR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +* +admissionregistration_v1%delete a MutatingWebhookConfiguration*9deleteAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +B +admissionregistration_v1;partially update the specified MutatingWebhookConfiguration*8patchAdmissionregistrationV1MutatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +a +200Z +X +OKR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration +f +201_ +] +CreatedR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jx +x-kubernetes-group-version-kindUSgroup: admissionregistration.k8s.io +kind: MutatingWebhookConfiguration +version: v1 +JI +GE"Cpath(name of the MutatingWebhookConfiguration"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string` +E/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations_& +admissionregistration_v1watchAdmissionregistrationV1ValidatingWebhookConfigurationList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jz +x-kubernetes-group-version-kindWUgroup: admissionregistration.k8s.io +kind: ValidatingWebhookConfiguration +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +R/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations/{name}( +admissionregistration_v1watch changes to an object of kind ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*:watchAdmissionregistrationV1ValidatingWebhookConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jz +x-kubernetes-group-version-kindWUgroup: admissionregistration.k8s.io +kind: ValidatingWebhookConfiguration +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJK +IG"Epath*name of the ValidatingWebhookConfiguration"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/apiextensions.k8s.io/ + apiextensionsget information of a group*getApiextensionsAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/apiextensions.k8s.io/v1/ +apiextensions_v1get available resources*getApiextensionsV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps_ +7/apis/apiextensions.k8s.io/v1/customresourcedefinitions_& +apiextensions_v16list or watch objects of kind CustomResourceDefinition*+listApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ +v +200o +m +OKg +e +c#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +" + +apiextensions_v1!create a CustomResourceDefinition*-createApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Bu +s +qbodybody *a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +w +201p +n +Createdc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +x +202q +o +Acceptedc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +*- +apiextensions_v1-delete collection of CustomResourceDefinition*7deleteApiextensionsV1CollectionCustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +>/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}- +apiextensions_v1+read the specified CustomResourceDefinition*+readApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 + + +apiextensions_v1.replace the specified CustomResourceDefinition*.replaceApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Bu +s +qbodybody *a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +w +201p +n +Createdc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +* +apiextensions_v1!delete a CustomResourceDefinition*-deleteApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +B +apiextensions_v17partially update the specified CustomResourceDefinition*,patchApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +w +201p +n +Createdc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +JE +CA"?path$name of the CustomResourceDefinition"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +E/apis/apiextensions.k8s.io/v1/customresourcedefinitions/{name}/status +apiextensions_v15read status of the specified CustomResourceDefinition*1readApiextensionsV1CustomResourceDefinitionStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 + + +apiextensions_v18replace status of the specified CustomResourceDefinition*4replaceApiextensionsV1CustomResourceDefinitionStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Bu +s +qbodybody *a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +w +201p +n +Createdc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +B +apiextensions_v1Apartially update status of the specified CustomResourceDefinition*2patchApiextensionsV1CustomResourceDefinitionStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +r +200k +i +OKc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition +w +201p +n +Createdc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +JE +CA"?path$name of the CustomResourceDefinition"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +=/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions' +apiextensions_v1watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead.*0watchApiextensionsV1CustomResourceDefinitionList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +D/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/{name}( +apiextensions_v1watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*,watchApiextensionsV1CustomResourceDefinition2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jl +x-kubernetes-group-version-kindIGgroup: apiextensions.k8s.io +kind: CustomResourceDefinition +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJE +CA"?path$name of the CustomResourceDefinition"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/apiregistration.k8s.io/ +apiregistrationget information of a group*getApiregistrationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps + /apis/apiregistration.k8s.io/v1/ +apiregistration_v1get available resources* getApiregistrationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps] ++/apis/apiregistration.k8s.io/v1/apiservices]% +apiregistration_v1(list or watch objects of kind APIService*listApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ} +b +200[ +Y +OKS +Q +O#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +" + +apiregistration_v1create an APIService*!createApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ba +_ +]bodybody *M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +c +201\ +Z +CreatedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +d +202] +[ +AcceptedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +*, +apiregistration_v1delete collection of APIService*+deleteApiregistrationV1CollectionAPIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +2/apis/apiregistration.k8s.io/v1/apiservices/{name}+ +apiregistration_v1read the specified APIService*readApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jy +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService + +apiregistration_v1 replace the specified APIService*"replaceApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ba +_ +]bodybody *M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +c +201\ +Z +CreatedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +* +apiregistration_v1delete an APIService*!deleteApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +B +apiregistration_v1)partially update the specified APIService* patchApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +c +201\ +Z +CreatedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +J7 +53"1pathname of the APIService"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +9/apis/apiregistration.k8s.io/v1/apiservices/{name}/status +apiregistration_v1'read status of the specified APIService*%readApiregistrationV1APIServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jy +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService + +apiregistration_v1*replace status of the specified APIService*(replaceApiregistrationV1APIServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ba +_ +]bodybody *M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +c +201\ +Z +CreatedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +B +apiregistration_v13partially update status of the specified APIService*&patchApiregistrationV1APIServiceStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +^ +200W +U +OKO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +c +201\ +Z +CreatedO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +J7 +53"1pathname of the APIService"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +1/apis/apiregistration.k8s.io/v1/watch/apiservices' +apiregistration_v1vwatch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead.*$watchApiregistrationV1APIServiceList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +8/apis/apiregistration.k8s.io/v1/watch/apiservices/{name}' +apiregistration_v1watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.* watchApiregistrationV1APIService2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j` +x-kubernetes-group-version-kind=;group: apiregistration.k8s.io +version: v1 +kind: APIService +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ7 +53"1pathname of the APIService"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean + /apis/apps/ +appsget information of a group*getAppsAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/apps/v1/ +apps_v1get available resources*getAppsV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +!/apis/apps/v1/controllerrevisions& +apps_v10list or watch objects of kind ControllerRevision*,listAppsV1ControllerRevisionForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.apps.v1.ControllerRevisionList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/apis/apps/v1/daemonsets% +apps_v1'list or watch objects of kind DaemonSet*#listAppsV1DaemonSetForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.apps.v1.DaemonSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/apis/apps/v1/deployments& +apps_v1(list or watch objects of kind Deployment*$listAppsV1DeploymentForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.apps.v1.DeploymentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +8/apis/apps/v1/namespaces/{namespace}/controllerrevisions]% +apps_v10list or watch objects of kind ControllerRevision*&listAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJe +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.apps.v1.ControllerRevisionList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +" +apps_v1create a ControllerRevision*(createAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevisionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision +L +202E +C +Accepted7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +*, +apps_v1'delete collection of ControllerRevision*2deleteAppsV1CollectionNamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +?/apis/apps/v1/namespaces/{namespace}/controllerrevisions/{name}* +apps_v1%read the specified ControllerRevision*&readAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ja +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 + +apps_v1(replace the specified ControllerRevision*)replaceAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevisionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +* +apps_v1delete a ControllerRevision*(deleteAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +B +apps_v11partially update the specified ControllerRevision*'patchAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J? +=;"9pathname of the ControllerRevision"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +//apis/apps/v1/namespaces/{namespace}/daemonsets\% +apps_v1'list or watch objects of kind DaemonSet*listAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.apps.v1.DaemonSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +" +apps_v1create a DaemonSet*createAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.apps.v1.DaemonSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +C +202< +: +Accepted. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +*, +apps_v1delete collection of DaemonSet*)deleteAppsV1CollectionNamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +6/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}) +apps_v1read the specified DaemonSet*readAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 + +apps_v1replace the specified DaemonSet* replaceAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.apps.v1.DaemonSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +* +apps_v1delete a DaemonSet*deleteAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +B +apps_v1(partially update the specified DaemonSet*patchAppsV1NamespacedDaemonSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J6 +42"0pathname of the DaemonSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +=/apis/apps/v1/namespaces/{namespace}/daemonsets/{name}/status +apps_v1&read status of the specified DaemonSet*#readAppsV1NamespacedDaemonSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JX += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 + +apps_v1)replace status of the specified DaemonSet*&replaceAppsV1NamespacedDaemonSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B@ +> +<bodybody *, +*#/definitions/io.k8s.api.apps.v1.DaemonSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +B +apps_v12partially update status of the specified DaemonSet*$patchAppsV1NamespacedDaemonSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ += +2006 +4 +OK. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet +B +201; +9 +Created. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J6 +42"0pathname of the DaemonSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +0/apis/apps/v1/namespaces/{namespace}/deployments\% +apps_v1(list or watch objects of kind Deployment*listAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.apps.v1.DeploymentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +" +apps_v1create a Deployment* createAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.DeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +*, +apps_v1delete collection of Deployment**deleteAppsV1CollectionNamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +7/apis/apps/v1/namespaces/{namespace}/deployments/{name}) +apps_v1read the specified Deployment*readAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 + +apps_v1 replace the specified Deployment*!replaceAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.DeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +* +apps_v1delete a Deployment* deleteAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +B +apps_v1)partially update the specified Deployment*patchAppsV1NamespacedDeployment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +J7 +53"1pathname of the Deployment"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +=/apis/apps/v1/namespaces/{namespace}/deployments/{name}/scale +apps_v1&read scale of the specified Deployment*#readAppsV1NamespacedDeploymentScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 + +apps_v1)replace scale of the specified Deployment*&replaceAppsV1NamespacedDeploymentScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.autoscaling.v1.ScaleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +B +apps_v12partially update scale of the specified Deployment*$patchAppsV1NamespacedDeploymentScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +J2 +0.",pathname of the Scale"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +>/apis/apps/v1/namespaces/{namespace}/deployments/{name}/status +apps_v1'read status of the specified Deployment*$readAppsV1NamespacedDeploymentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 + +apps_v1*replace status of the specified Deployment*'replaceAppsV1NamespacedDeploymentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.DeploymentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +B +apps_v13partially update status of the specified Deployment*%patchAppsV1NamespacedDeploymentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +J7 +53"1pathname of the Deployment"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +0/apis/apps/v1/namespaces/{namespace}/replicasets\% +apps_v1(list or watch objects of kind ReplicaSet*listAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.apps.v1.ReplicaSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +" +apps_v1create a ReplicaSet* createAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.ReplicaSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +*, +apps_v1delete collection of ReplicaSet**deleteAppsV1CollectionNamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +7/apis/apps/v1/namespaces/{namespace}/replicasets/{name}) +apps_v1read the specified ReplicaSet*readAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 + +apps_v1 replace the specified ReplicaSet*!replaceAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.ReplicaSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +* +apps_v1delete a ReplicaSet* deleteAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +B +apps_v1)partially update the specified ReplicaSet*patchAppsV1NamespacedReplicaSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +J7 +53"1pathname of the ReplicaSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +=/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/scale +apps_v1&read scale of the specified ReplicaSet*#readAppsV1NamespacedReplicaSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 + +apps_v1)replace scale of the specified ReplicaSet*&replaceAppsV1NamespacedReplicaSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.autoscaling.v1.ScaleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +B +apps_v12partially update scale of the specified ReplicaSet*$patchAppsV1NamespacedReplicaSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +J2 +0.",pathname of the Scale"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +>/apis/apps/v1/namespaces/{namespace}/replicasets/{name}/status +apps_v1'read status of the specified ReplicaSet*$readAppsV1NamespacedReplicaSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 + +apps_v1*replace status of the specified ReplicaSet*'replaceAppsV1NamespacedReplicaSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.apps.v1.ReplicaSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +B +apps_v13partially update status of the specified ReplicaSet*%patchAppsV1NamespacedReplicaSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +J7 +53"1pathname of the ReplicaSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +1/apis/apps/v1/namespaces/{namespace}/statefulsets\% +apps_v1)list or watch objects of kind StatefulSet*listAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.apps.v1.StatefulSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +" +apps_v1create a StatefulSet*!createAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.apps.v1.StatefulSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +E +202> +< +Accepted0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +*, +apps_v1 delete collection of StatefulSet*+deleteAppsV1CollectionNamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +8/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}) +apps_v1read the specified StatefulSet*readAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 + +apps_v1!replace the specified StatefulSet*"replaceAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.apps.v1.StatefulSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +* +apps_v1delete a StatefulSet*!deleteAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +B +apps_v1*partially update the specified StatefulSet* patchAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J8 +64"2pathname of the StatefulSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +>/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/scale +apps_v1'read scale of the specified StatefulSet*$readAppsV1NamespacedStatefulSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 + +apps_v1*replace scale of the specified StatefulSet*'replaceAppsV1NamespacedStatefulSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.autoscaling.v1.ScaleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +B +apps_v13partially update scale of the specified StatefulSet*%patchAppsV1NamespacedStatefulSetScale2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.autoscaling.v1.Scale + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jP +x-kubernetes-group-version-kind-+group: autoscaling +kind: Scale +version: v1 +J2 +0.",pathname of the Scale"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +?/apis/apps/v1/namespaces/{namespace}/statefulsets/{name}/status +apps_v1(read status of the specified StatefulSet*%readAppsV1NamespacedStatefulSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 + +apps_v1+replace status of the specified StatefulSet*(replaceAppsV1NamespacedStatefulSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.apps.v1.StatefulSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +B +apps_v14partially update status of the specified StatefulSet*&patchAppsV1NamespacedStatefulSetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J8 +64"2pathname of the StatefulSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +/apis/apps/v1/replicasets& +apps_v1(list or watch objects of kind ReplicaSet*$listAppsV1ReplicaSetForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.apps.v1.ReplicaSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/apis/apps/v1/statefulsets& +apps_v1)list or watch objects of kind StatefulSet*%listAppsV1StatefulSetForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.apps.v1.StatefulSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +'/apis/apps/v1/watch/controllerrevisions' +apps_v1~watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.*1watchAppsV1ControllerRevisionListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/apis/apps/v1/watch/daemonsets& +apps_v1uwatch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.*(watchAppsV1DaemonSetListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/apis/apps/v1/watch/deployments& +apps_v1vwatch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead.*)watchAppsV1DeploymentListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: Deployment +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +>/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions' +apps_v1~watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead.*+watchAppsV1NamespacedControllerRevisionList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +E/apis/apps/v1/watch/namespaces/{namespace}/controllerrevisions/{name}( +apps_v1watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*'watchAppsV1NamespacedControllerRevision2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jV +x-kubernetes-group-version-kind31group: apps +kind: ControllerRevision +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ? +=;"9pathname of the ControllerRevision"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +5/apis/apps/v1/watch/namespaces/{namespace}/daemonsets' +apps_v1uwatch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead.*"watchAppsV1NamespacedDaemonSetList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jM +x-kubernetes-group-version-kind*(group: apps +kind: DaemonSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +/apis/apps/v1/watch/namespaces/{namespace}/statefulsets/{name}( +apps_v1watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.* watchAppsV1NamespacedStatefulSet2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ8 +64"2pathname of the StatefulSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +/apis/apps/v1/watch/replicasets& +apps_v1vwatch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead.*)watchAppsV1ReplicaSetListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jN +x-kubernetes-group-version-kind+)group: apps +kind: ReplicaSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' + /apis/apps/v1/watch/statefulsets& +apps_v1wwatch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead.**watchAppsV1StatefulSetListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jO +x-kubernetes-group-version-kind,*group: apps +kind: StatefulSet +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean% +'/apis/argoproj.io/v1alpha1/analysisruns% +argoprojIo_v1alpha1 list objects of kind AnalysisRun*1listArgoprojIoV1alpha1AnalysisRunForAllNamespaces2application/json2application/yaml:application/json:application/yamlJ` +E +200> +< +OK6 +4 +2#/definitions/io.argoproj.v1alpha1.AnalysisRunList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +,/apis/argoproj.io/v1alpha1/analysistemplates% +argoprojIo_v1alpha1%list objects of kind AnalysisTemplate*6listArgoprojIoV1alpha1AnalysisTemplateForAllNamespaces2application/json2application/yaml:application/json:application/yamlJe +J +200C +A +OK; +9 +7#/definitions/io.argoproj.v1alpha1.AnalysisTemplateList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +ja +x-kubernetes-group-version-kind> +< +OK6 +4 +2#/definitions/io.argoproj.v1alpha1.ApplicationList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +*/apis/argoproj.io/v1alpha1/applicationsets% +argoprojIo_v1alpha1#list objects of kind ApplicationSet*4listArgoprojIoV1alpha1ApplicationSetForAllNamespaces2application/json2application/yaml:application/json:application/yamlJc +H +200A +? +OK9 +7 +5#/definitions/io.argoproj.v1alpha1.ApplicationSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean% +&/apis/argoproj.io/v1alpha1/appprojects% +argoprojIo_v1alpha1list objects of kind AppProject*0listArgoprojIoV1alpha1AppProjectForAllNamespaces2application/json2application/yaml:application/json:application/yamlJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.AppProjectList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanU +3/apis/argoproj.io/v1alpha1/clusteranalysistemplatesU% +argoprojIo_v1alpha1,list objects of kind ClusterAnalysisTemplate*-listArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJl +Q +200J +H +OKB +@ +>#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplateList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +" +argoprojIo_v1alpha1 create a ClusterAnalysisTemplate*/createArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlBP +N +Lbodybody *< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplateB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +M +200F +D +OK> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate +R +201K +I +Created> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate +S +202L +J +Accepted> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +*% +argoprojIo_v1alpha1,delete collection of ClusterAnalysisTemplate*9deleteArgoprojIoV1alpha1CollectionClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +:/apis/argoproj.io/v1alpha1/clusteranalysistemplates/{name}) +argoprojIo_v1alpha1*read the specified ClusterAnalysisTemplate*-readArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJh +M +200F +D +OK> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 + +argoprojIo_v1alpha1-replace the specified ClusterAnalysisTemplate*0replaceArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlBP +N +Lbodybody *< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplateB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +M +200F +D +OK> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate +R +201K +I +Created> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +* +argoprojIo_v1alpha1 delete a ClusterAnalysisTemplate*/deleteArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +B +argoprojIo_v1alpha16partially update the specified ClusterAnalysisTemplate*.patchArgoprojIoV1alpha1ClusterAnalysisTemplate2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJh +M +200F +D +OK> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jh +x-kubernetes-group-version-kindECgroup: argoproj.io +kind: ClusterAnalysisTemplate +version: v1alpha1 +JD +B@">path#name of the ClusterAnalysisTemplate"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string% +&/apis/argoproj.io/v1alpha1/experiments% +argoprojIo_v1alpha1list objects of kind Experiment*0listArgoprojIoV1alpha1ExperimentForAllNamespaces2application/json2application/yaml:application/json:application/yamlJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ExperimentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanU +>/apis/argoproj.io/v1alpha1/namespaces/{namespace}/analysisrunsT$ +argoprojIo_v1alpha1 list objects of kind AnalysisRun*+listArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.argoproj.v1alpha1.AnalysisRunList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +" +argoprojIo_v1alpha1create an AnalysisRun*-createArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlBD +B +@bodybody *0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRunB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun +F +201? += +Created2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun +G +202@ +> +Accepted2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +*% +argoprojIo_v1alpha1 delete collection of AnalysisRun*7deleteArgoprojIoV1alpha1CollectionNamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +E/apis/argoproj.io/v1alpha1/namespaces/{namespace}/analysisruns/{name}( +argoprojIo_v1alpha1read the specified AnalysisRun*+readArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 + +argoprojIo_v1alpha1!replace the specified AnalysisRun*.replaceArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlBD +B +@bodybody *0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRunB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun +F +201? += +Created2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +* +argoprojIo_v1alpha1delete an AnalysisRun*-deleteArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +B +argoprojIo_v1alpha1*partially update the specified AnalysisRun*,patchArgoprojIoV1alpha1NamespacedAnalysisRun2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: AnalysisRun +version: v1alpha1 +J8 +64"2pathname of the AnalysisRun"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringU +C/apis/argoproj.io/v1alpha1/namespaces/{namespace}/analysistemplatesU% +argoprojIo_v1alpha1%list objects of kind AnalysisTemplate*0listArgoprojIoV1alpha1NamespacedAnalysisTemplate2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJe +J +200C +A +OK; +9 +7#/definitions/io.argoproj.v1alpha1.AnalysisTemplateList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +ja +x-kubernetes-group-version-kind> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +ja +x-kubernetes-group-version-kind> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +ja +x-kubernetes-group-version-kind>/apis/argoproj.io/v1alpha1/namespaces/{namespace}/applicationsT$ +argoprojIo_v1alpha1 list objects of kind Application*+listArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.argoproj.v1alpha1.ApplicationList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +" +argoprojIo_v1alpha1create an Application*-createArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json:application/yamlBD +B +@bodybody *0 +.#/definitions/io.argoproj.v1alpha1.ApplicationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.Application +F +201? += +Created2 +0 +.#/definitions/io.argoproj.v1alpha1.Application +G +202@ +> +Accepted2 +0 +.#/definitions/io.argoproj.v1alpha1.Application + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +*% +argoprojIo_v1alpha1 delete collection of Application*7deleteArgoprojIoV1alpha1CollectionNamespacedApplication2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +E/apis/argoproj.io/v1alpha1/namespaces/{namespace}/applications/{name}( +argoprojIo_v1alpha1read the specified Application*+readArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.Application + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 + +argoprojIo_v1alpha1!replace the specified Application*.replaceArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json:application/yamlBD +B +@bodybody *0 +.#/definitions/io.argoproj.v1alpha1.ApplicationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.Application +F +201? += +Created2 +0 +.#/definitions/io.argoproj.v1alpha1.Application + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +* +argoprojIo_v1alpha1delete an Application*-deleteArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +B +argoprojIo_v1alpha1*partially update the specified Application*,patchArgoprojIoV1alpha1NamespacedApplication2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.Application + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j\ +x-kubernetes-group-version-kind97group: argoproj.io +kind: Application +version: v1alpha1 +J8 +64"2pathname of the Application"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringU +A/apis/argoproj.io/v1alpha1/namespaces/{namespace}/applicationsetsU% +argoprojIo_v1alpha1#list objects of kind ApplicationSet*.listArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJc +H +200A +? +OK9 +7 +5#/definitions/io.argoproj.v1alpha1.ApplicationSetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +" +argoprojIo_v1alpha1create an ApplicationSet*0createArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlBG +E +Cbodybody *3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet +I +201B +@ +Created5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet +J +202C +A +Accepted5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +*% +argoprojIo_v1alpha1#delete collection of ApplicationSet*:deleteArgoprojIoV1alpha1CollectionNamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +H/apis/argoproj.io/v1alpha1/namespaces/{namespace}/applicationsets/{name}) +argoprojIo_v1alpha1!read the specified ApplicationSet*.readArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 + +argoprojIo_v1alpha1$replace the specified ApplicationSet*1replaceArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlBG +E +Cbodybody *3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet +I +201B +@ +Created5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +* +argoprojIo_v1alpha1delete an ApplicationSet*0deleteArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +B +argoprojIo_v1alpha1-partially update the specified ApplicationSet*/patchArgoprojIoV1alpha1NamespacedApplicationSet2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +J; +97"5pathname of the ApplicationSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +O/apis/argoproj.io/v1alpha1/namespaces/{namespace}/applicationsets/{name}/status +argoprojIo_v1alpha1+read status of the specified ApplicationSet*4readArgoprojIoV1alpha1NamespacedApplicationSetStatus2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 + +argoprojIo_v1alpha1.replace status of the specified ApplicationSet*7replaceArgoprojIoV1alpha1NamespacedApplicationSetStatus2application/json2application/yaml:application/json:application/yamlBG +E +Cbodybody *3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet +I +201B +@ +Created5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +B +argoprojIo_v1alpha17partially update status of the specified ApplicationSet*5patchArgoprojIoV1alpha1NamespacedApplicationSetStatus2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j_ +x-kubernetes-group-version-kind<:group: argoproj.io +kind: ApplicationSet +version: v1alpha1 +J; +97"5pathname of the ApplicationSet"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringU +=/apis/argoproj.io/v1alpha1/namespaces/{namespace}/appprojectsT$ +argoprojIo_v1alpha1list objects of kind AppProject**listArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.AppProjectList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +" +argoprojIo_v1alpha1create an AppProject*,createArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json:application/yamlBC +A +?bodybody */ +-#/definitions/io.argoproj.v1alpha1.AppProjectB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject +E +201> +< +Created1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject +F +202? += +Accepted1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +*% +argoprojIo_v1alpha1delete collection of AppProject*6deleteArgoprojIoV1alpha1CollectionNamespacedAppProject2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +D/apis/argoproj.io/v1alpha1/namespaces/{namespace}/appprojects/{name}( +argoprojIo_v1alpha1read the specified AppProject**readArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 + +argoprojIo_v1alpha1 replace the specified AppProject*-replaceArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json:application/yamlBC +A +?bodybody */ +-#/definitions/io.argoproj.v1alpha1.AppProjectB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject +E +201> +< +Created1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +* +argoprojIo_v1alpha1delete an AppProject*,deleteArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +B +argoprojIo_v1alpha1)partially update the specified AppProject*+patchArgoprojIoV1alpha1NamespacedAppProject2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: AppProject +version: v1alpha1 +J7 +53"1pathname of the AppProject"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringU +=/apis/argoproj.io/v1alpha1/namespaces/{namespace}/experimentsT$ +argoprojIo_v1alpha1list objects of kind Experiment**listArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ_ +D +200= +; +OK5 +3 +1#/definitions/io.argoproj.v1alpha1.ExperimentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +" +argoprojIo_v1alpha1create an Experiment*,createArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json:application/yamlBC +A +?bodybody */ +-#/definitions/io.argoproj.v1alpha1.ExperimentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment +E +201> +< +Created1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment +F +202? += +Accepted1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +*% +argoprojIo_v1alpha1delete collection of Experiment*6deleteArgoprojIoV1alpha1CollectionNamespacedExperiment2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +D/apis/argoproj.io/v1alpha1/namespaces/{namespace}/experiments/{name}( +argoprojIo_v1alpha1read the specified Experiment**readArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 + +argoprojIo_v1alpha1 replace the specified Experiment*-replaceArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json:application/yamlBC +A +?bodybody */ +-#/definitions/io.argoproj.v1alpha1.ExperimentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment +E +201> +< +Created1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +* +argoprojIo_v1alpha1delete an Experiment*,deleteArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +B +argoprojIo_v1alpha1)partially update the specified Experiment*+patchArgoprojIoV1alpha1NamespacedExperiment2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j[ +x-kubernetes-group-version-kind86group: argoproj.io +kind: Experiment +version: v1alpha1 +J7 +53"1pathname of the Experiment"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringT +:/apis/argoproj.io/v1alpha1/namespaces/{namespace}/rolloutsT$ +argoprojIo_v1alpha1list objects of kind Rollout*'listArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.RolloutList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +" +argoprojIo_v1alpha1create a Rollout*)createArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json:application/yamlB@ +> +<bodybody *, +*#/definitions/io.argoproj.v1alpha1.RolloutB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout +B +201; +9 +Created. +, +*#/definitions/io.argoproj.v1alpha1.Rollout +C +202< +: +Accepted. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +*% +argoprojIo_v1alpha1delete collection of Rollout*3deleteArgoprojIoV1alpha1CollectionNamespacedRollout2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string( +A/apis/argoproj.io/v1alpha1/namespaces/{namespace}/rollouts/{name}( +argoprojIo_v1alpha1read the specified Rollout*'readArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJX += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 + +argoprojIo_v1alpha1replace the specified Rollout**replaceArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json:application/yamlB@ +> +<bodybody *, +*#/definitions/io.argoproj.v1alpha1.RolloutB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout +B +201; +9 +Created. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +* +argoprojIo_v1alpha1delete a Rollout*)deleteArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +B +argoprojIo_v1alpha1&partially update the specified Rollout*(patchArgoprojIoV1alpha1NamespacedRollout2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJX += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +J4 +20".pathname of the Rollout"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +G/apis/argoproj.io/v1alpha1/namespaces/{namespace}/rollouts/{name}/scale +argoprojIo_v1alpha1#read scale of the specified Rollout*,readArgoprojIoV1alpha1NamespacedRolloutScale2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.autoscaling.v1.Scale_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 + +argoprojIo_v1alpha1&replace scale of the specified Rollout*/replaceArgoprojIoV1alpha1NamespacedRolloutScale2application/json2application/yaml:application/json:application/yamlBF +D +Bbodybody *2 +0#/definitions/io.k8s.api.autoscaling.v1.Scale_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.autoscaling.v1.Scale_v2 +H +201A +? +Created4 +2 +0#/definitions/io.k8s.api.autoscaling.v1.Scale_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +B +argoprojIo_v1alpha1/partially update scale of the specified Rollout*-patchArgoprojIoV1alpha1NamespacedRolloutScale2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.autoscaling.v1.Scale_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +J4 +20".pathname of the Rollout"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +H/apis/argoproj.io/v1alpha1/namespaces/{namespace}/rollouts/{name}/status +argoprojIo_v1alpha1$read status of the specified Rollout*-readArgoprojIoV1alpha1NamespacedRolloutStatus2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJX += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 + +argoprojIo_v1alpha1'replace status of the specified Rollout*0replaceArgoprojIoV1alpha1NamespacedRolloutStatus2application/json2application/yaml:application/json:application/yamlB@ +> +<bodybody *, +*#/definitions/io.argoproj.v1alpha1.RolloutB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout +B +201; +9 +Created. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +B +argoprojIo_v1alpha10partially update status of the specified Rollout*.patchArgoprojIoV1alpha1NamespacedRolloutStatus2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJX += +2006 +4 +OK. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +J4 +20".pathname of the Rollout"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string% +#/apis/argoproj.io/v1alpha1/rollouts% +argoprojIo_v1alpha1list objects of kind Rollout*-listArgoprojIoV1alpha1RolloutForAllNamespaces2application/json2application/yaml:application/json:application/yamlJ\ +A +200: +8 +OK2 +0 +.#/definitions/io.argoproj.v1alpha1.RolloutList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: argoproj.io +kind: Rollout +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/authentication.k8s.io/ +authenticationget information of a group*getAuthenticationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/authentication.k8s.io/v1/ +authentication_v1get available resources*getAuthenticationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps + ++/apis/authentication.k8s.io/v1/tokenreviews +" +authentication_v1create a TokenReview*!createAuthenticationV1TokenReview2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.authentication.v1.TokenReviewJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.authentication.v1.TokenReview +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.authentication.v1.TokenReview +O +202H +F +Accepted: +8 +6#/definitions/io.k8s.api.authentication.v1.TokenReview + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j` +x-kubernetes-group-version-kind=;group: authentication.k8s.io +kind: TokenReview +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +/apis/authorization.k8s.io/ + authorizationget information of a group*getAuthorizationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/authorization.k8s.io/v1/ +authorization_v1get available resources*getAuthorizationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps +N/apis/authorization.k8s.io/v1/namespaces/{namespace}/localsubjectaccessreviews " +authorization_v1!create a LocalSubjectAccessReview*7createAuthorizationV1NamespacedLocalSubjectAccessReview2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BX +V +Tbodybody *D +B#/definitions/io.k8s.api.authorization.v1.LocalSubjectAccessReviewJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.authorization.v1.LocalSubjectAccessReview +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.authorization.v1.LocalSubjectAccessReview +[ +202T +R +AcceptedF +D +B#/definitions/io.k8s.api.authorization.v1.LocalSubjectAccessReview + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jl +x-kubernetes-group-version-kindIGgroup: authorization.k8s.io +kind: LocalSubjectAccessReview +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +6/apis/authorization.k8s.io/v1/selfsubjectaccessreviews +" +authorization_v1 create a SelfSubjectAccessReview*,createAuthorizationV1SelfSubjectAccessReview2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BW +U +Sbodybody *C +A#/definitions/io.k8s.api.authorization.v1.SelfSubjectAccessReviewJ +T +200M +K +OKE +C +A#/definitions/io.k8s.api.authorization.v1.SelfSubjectAccessReview +Y +201R +P +CreatedE +C +A#/definitions/io.k8s.api.authorization.v1.SelfSubjectAccessReview +Z +202S +Q +AcceptedE +C +A#/definitions/io.k8s.api.authorization.v1.SelfSubjectAccessReview + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jk +x-kubernetes-group-version-kindHFgroup: authorization.k8s.io +kind: SelfSubjectAccessReview +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +5/apis/authorization.k8s.io/v1/selfsubjectrulesreviews +" +authorization_v1create a SelfSubjectRulesReview*+createAuthorizationV1SelfSubjectRulesReview2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BV +T +Rbodybody *B +@#/definitions/io.k8s.api.authorization.v1.SelfSubjectRulesReviewJ +S +200L +J +OKD +B +@#/definitions/io.k8s.api.authorization.v1.SelfSubjectRulesReview +X +201Q +O +CreatedD +B +@#/definitions/io.k8s.api.authorization.v1.SelfSubjectRulesReview +Y +202R +P +AcceptedD +B +@#/definitions/io.k8s.api.authorization.v1.SelfSubjectRulesReview + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jj +x-kubernetes-group-version-kindGEgroup: authorization.k8s.io +kind: SelfSubjectRulesReview +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string + +2/apis/authorization.k8s.io/v1/subjectaccessreviews +" +authorization_v1create a SubjectAccessReview*(createAuthorizationV1SubjectAccessReview2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BS +Q +Obodybody *? +=#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewJ +P +200I +G +OKA +? +=#/definitions/io.k8s.api.authorization.v1.SubjectAccessReview +U +201N +L +CreatedA +? +=#/definitions/io.k8s.api.authorization.v1.SubjectAccessReview +V +202O +M +AcceptedA +? +=#/definitions/io.k8s.api.authorization.v1.SubjectAccessReview + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jg +x-kubernetes-group-version-kindDBgroup: authorization.k8s.io +kind: SubjectAccessReview +version: v1 +J +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringJ +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringW +S/apis/autoscaling.k8s.io/v1/namespaces/{namespace}/verticalpodautoscalercheckpointsV% +autoscaling_v14list objects of kind VerticalPodAutoscalerCheckpoint*:listAutoscalingV1NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJu +Z +200S +Q +OKK +I +G#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpointList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 +" + +autoscaling_v1(create a VerticalPodAutoscalerCheckpoint* +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +Z/apis/autoscaling.k8s.io/v1/namespaces/{namespace}/verticalpodautoscalercheckpoints/{name}+ +autoscaling_v12read the specified VerticalPodAutoscalerCheckpoint*:readAutoscalingV1NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJq +V +200O +M +OKG +E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 + +autoscaling_v15replace the specified VerticalPodAutoscalerCheckpoint*=replaceAutoscalingV1NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlBY +W +Ubodybody *E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpointB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +V +200O +M +OKG +E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpoint +[ +201T +R +CreatedG +E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 +* +autoscaling_v1(delete a VerticalPodAutoscalerCheckpoint* +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 +B +autoscaling_v1>partially update the specified VerticalPodAutoscalerCheckpoint*;patchAutoscalingV1NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJq +V +200O +M +OKG +E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jq +x-kubernetes-group-version-kindNLgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1 +JL +JH"Fpath+name of the VerticalPodAutoscalerCheckpoint"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringV +I/apis/autoscaling.k8s.io/v1/namespaces/{namespace}/verticalpodautoscalersU% +autoscaling_v1*list objects of kind VerticalPodAutoscaler*0listAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJk +P +200I +G +OKA +? +=#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +" +autoscaling_v1create a VerticalPodAutoscaler*2createAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBO +M +Kbodybody *; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler +Q +201J +H +Created= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler +R +202K +I +Accepted= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +*% +autoscaling_v1*delete collection of VerticalPodAutoscaler* +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +P/apis/autoscaling.k8s.io/v1/namespaces/{namespace}/verticalpodautoscalers/{name}) +autoscaling_v1(read the specified VerticalPodAutoscaler*0readAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJg +L +200E +C +OK= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 + +autoscaling_v1+replace the specified VerticalPodAutoscaler*3replaceAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBO +M +Kbodybody *; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler +Q +201J +H +Created= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +* +autoscaling_v1delete a VerticalPodAutoscaler*2deleteAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +B +autoscaling_v14partially update the specified VerticalPodAutoscaler*1patchAutoscalingV1NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJg +L +200E +C +OK= +; +9#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jg +x-kubernetes-group-version-kindDBgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1 +JB +@>"<path!name of the VerticalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& + +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +_/apis/autoscaling.k8s.io/v1beta2/namespaces/{namespace}/verticalpodautoscalercheckpoints/{name}, +autoscaling_v1beta22read the specified VerticalPodAutoscalerCheckpoint*?readAutoscalingV1beta2NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJv +[ +200T +R +OKL +J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 + +autoscaling_v1beta25replace the specified VerticalPodAutoscalerCheckpoint*BreplaceAutoscalingV1beta2NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlB^ +\ +Zbodybody *J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpointB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +[ +200T +R +OKL +J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpoint +` +201Y +W +CreatedL +J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 +* +autoscaling_v1beta2(delete a VerticalPodAutoscalerCheckpoint*AdeleteAutoscalingV1beta2NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 +B +autoscaling_v1beta2>partially update the specified VerticalPodAutoscalerCheckpoint*@patchAutoscalingV1beta2NamespacedVerticalPodAutoscalerCheckpoint2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJv +[ +200T +R +OKL +J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpoint + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 +JL +JH"Fpath+name of the VerticalPodAutoscalerCheckpoint"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringV +N/apis/autoscaling.k8s.io/v1beta2/namespaces/{namespace}/verticalpodautoscalersV% +autoscaling_v1beta2*list objects of kind VerticalPodAutoscaler*5listAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJp +U +200N +L +OKF +D +B#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +" +autoscaling_v1beta2create a VerticalPodAutoscaler*7createAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBT +R +Pbodybody *@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Q +200J +H +OKB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler +V +201O +M +CreatedB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler +W +202P +N +AcceptedB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +*% +autoscaling_v1beta2*delete collection of VerticalPodAutoscaler*AdeleteAutoscalingV1beta2CollectionNamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +U/apis/autoscaling.k8s.io/v1beta2/namespaces/{namespace}/verticalpodautoscalers/{name}* +autoscaling_v1beta2(read the specified VerticalPodAutoscaler*5readAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJl +Q +200J +H +OKB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 + +autoscaling_v1beta2+replace the specified VerticalPodAutoscaler*8replaceAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBT +R +Pbodybody *@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Q +200J +H +OKB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler +V +201O +M +CreatedB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +* +autoscaling_v1beta2delete a VerticalPodAutoscaler*7deleteAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +B +autoscaling_v1beta24partially update the specified VerticalPodAutoscaler*6patchAutoscalingV1beta2NamespacedVerticalPodAutoscaler2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJl +Q +200J +H +OKB +@ +>#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +JB +@>"<path!name of the VerticalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +A/apis/autoscaling.k8s.io/v1beta2/verticalpodautoscalercheckpoints& +autoscaling_v1beta24list objects of kind VerticalPodAutoscalerCheckpoint*ElistAutoscalingV1beta2VerticalPodAutoscalerCheckpointForAllNamespaces2application/json2application/yaml:application/json:application/yamlJz +_ +200X +V +OKP +N +L#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpointList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jv +x-kubernetes-group-version-kindSQgroup: autoscaling.k8s.io +kind: VerticalPodAutoscalerCheckpoint +version: v1beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +7/apis/autoscaling.k8s.io/v1beta2/verticalpodautoscalers& +autoscaling_v1beta2*list objects of kind VerticalPodAutoscaler*;listAutoscalingV1beta2VerticalPodAutoscalerForAllNamespaces2application/json2application/yaml:application/json:application/yamlJp +U +200N +L +OKF +D +B#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: autoscaling.k8s.io +kind: VerticalPodAutoscaler +version: v1beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/autoscaling/ + autoscalingget information of a group*getAutoscalingAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/autoscaling/v1/ +autoscaling_v1get available resources*getAutoscalingV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps' +-/apis/autoscaling/v1/horizontalpodautoscalers& +autoscaling_v15list or watch objects of kind HorizontalPodAutoscaler*8listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jq +V +200O +M +OKG +E +C#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean^ +D/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers^% +autoscaling_v15list or watch objects of kind HorizontalPodAutoscaler*2listAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJq +V +200O +M +OKG +E +C#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +" +autoscaling_v1 create a HorizontalPodAutoscaler*4createAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +X +202Q +O +AcceptedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +*- +autoscaling_v1,delete collection of HorizontalPodAutoscaler*>deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +K/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}, +autoscaling_v1*read the specified HorizontalPodAutoscaler*2readAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 + +autoscaling_v1-replace the specified HorizontalPodAutoscaler*5replaceAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +* +autoscaling_v1 delete a HorizontalPodAutoscaler*4deleteAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +B +autoscaling_v16partially update the specified HorizontalPodAutoscaler*3patchAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +R/apis/autoscaling/v1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status +autoscaling_v14read status of the specified HorizontalPodAutoscaler*8readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 + +autoscaling_v17replace status of the specified HorizontalPodAutoscaler*;replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +B +autoscaling_v1@partially update status of the specified HorizontalPodAutoscaler*9patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +3/apis/autoscaling/v1/watch/horizontalpodautoscalers' +autoscaling_v1watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*=watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +J/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers( +autoscaling_v1watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*7watchAutoscalingV1NamespacedHorizontalPodAutoscalerList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +Q/apis/autoscaling/v1/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}( +autoscaling_v1watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*3watchAutoscalingV1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/autoscaling/v2/ +autoscaling_v2get available resources*getAutoscalingV2APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps' +-/apis/autoscaling/v2/horizontalpodautoscalers& +autoscaling_v25list or watch objects of kind HorizontalPodAutoscaler*8listAutoscalingV2HorizontalPodAutoscalerForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jq +V +200O +M +OKG +E +C#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean^ +D/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers^% +autoscaling_v25list or watch objects of kind HorizontalPodAutoscaler*2listAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJq +V +200O +M +OKG +E +C#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +" +autoscaling_v2 create a HorizontalPodAutoscaler*4createAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +X +202Q +O +AcceptedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +*- +autoscaling_v2,delete collection of HorizontalPodAutoscaler*>deleteAutoscalingV2CollectionNamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +K/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}, +autoscaling_v2*read the specified HorizontalPodAutoscaler*2readAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 + +autoscaling_v2-replace the specified HorizontalPodAutoscaler*5replaceAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +* +autoscaling_v2 delete a HorizontalPodAutoscaler*4deleteAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +B +autoscaling_v26partially update the specified HorizontalPodAutoscaler*3patchAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +R/apis/autoscaling/v2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status +autoscaling_v24read status of the specified HorizontalPodAutoscaler*8readAutoscalingV2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 + +autoscaling_v27replace status of the specified HorizontalPodAutoscaler*;replaceAutoscalingV2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BU +S +Qbodybody *A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +B +autoscaling_v2@partially update status of the specified HorizontalPodAutoscaler*9patchAutoscalingV2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +R +200K +I +OKC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler +W +201P +N +CreatedC +A +?#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +3/apis/autoscaling/v2/watch/horizontalpodautoscalers' +autoscaling_v2watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*=watchAutoscalingV2HorizontalPodAutoscalerListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +J/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers( +autoscaling_v2watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*7watchAutoscalingV2NamespacedHorizontalPodAutoscalerList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +Q/apis/autoscaling/v2/watch/namespaces/{namespace}/horizontalpodautoscalers/{name}( +autoscaling_v2watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*3watchAutoscalingV2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jb +x-kubernetes-group-version-kind?=group: autoscaling +kind: HorizontalPodAutoscaler +version: v2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/autoscaling/v2beta1/ +autoscaling_v2beta1get available resources*!getAutoscalingV2beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps' +2/apis/autoscaling/v2beta1/horizontalpodautoscalers& +autoscaling_v2beta15list or watch objects of kind HorizontalPodAutoscaler*=listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jv +[ +200T +R +OKL +J +H#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean_ +I/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers^& +autoscaling_v2beta15list or watch objects of kind HorizontalPodAutoscaler*7listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJv +[ +200T +R +OKL +J +H#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +" + +autoscaling_v2beta1 create a HorizontalPodAutoscaler*9createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +] +202V +T +AcceptedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +*- +autoscaling_v2beta1,delete collection of HorizontalPodAutoscaler*CdeleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +P/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}- +autoscaling_v2beta1*read the specified HorizontalPodAutoscaler*7readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jr +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 + +autoscaling_v2beta1-replace the specified HorizontalPodAutoscaler*:replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +* +autoscaling_v2beta1 delete a HorizontalPodAutoscaler*9deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +B +autoscaling_v2beta16partially update the specified HorizontalPodAutoscaler*8patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +W/apis/autoscaling/v2beta1/namespaces/{namespace}/horizontalpodautoscalers/{name}/status +autoscaling_v2beta14read status of the specified HorizontalPodAutoscaler*=readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jr +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 + +autoscaling_v2beta17replace status of the specified HorizontalPodAutoscaler*@replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +B +autoscaling_v2beta1@partially update status of the specified HorizontalPodAutoscaler*>patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +8/apis/autoscaling/v2beta1/watch/horizontalpodautoscalers' +autoscaling_v2beta1watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*BwatchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +O/apis/autoscaling/v2beta1/watch/namespaces/{namespace}/horizontalpodautoscalers( +autoscaling_v2beta1watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/autoscaling/v2beta2/ +autoscaling_v2beta2get available resources*!getAutoscalingV2beta2APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps' +2/apis/autoscaling/v2beta2/horizontalpodautoscalers& +autoscaling_v2beta25list or watch objects of kind HorizontalPodAutoscaler*=listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jv +[ +200T +R +OKL +J +H#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean_ +I/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers^& +autoscaling_v2beta25list or watch objects of kind HorizontalPodAutoscaler*7listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJv +[ +200T +R +OKL +J +H#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +" + +autoscaling_v2beta2 create a HorizontalPodAutoscaler*9createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +] +202V +T +AcceptedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +*- +autoscaling_v2beta2,delete collection of HorizontalPodAutoscaler*CdeleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +P/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}- +autoscaling_v2beta2*read the specified HorizontalPodAutoscaler*7readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jr +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 + +autoscaling_v2beta2-replace the specified HorizontalPodAutoscaler*:replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +* +autoscaling_v2beta2 delete a HorizontalPodAutoscaler*9deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +B +autoscaling_v2beta26partially update the specified HorizontalPodAutoscaler*8patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +W/apis/autoscaling/v2beta2/namespaces/{namespace}/horizontalpodautoscalers/{name}/status +autoscaling_v2beta24read status of the specified HorizontalPodAutoscaler*=readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jr +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 + +autoscaling_v2beta27replace status of the specified HorizontalPodAutoscaler*@replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BZ +X +Vbodybody *F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +B +autoscaling_v2beta2@partially update status of the specified HorizontalPodAutoscaler*>patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +W +200P +N +OKH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler +\ +201U +S +CreatedH +F +D#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +JD +B@">path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +8/apis/autoscaling/v2beta2/watch/horizontalpodautoscalers' +autoscaling_v2beta2watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*BwatchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jg +x-kubernetes-group-version-kindDBgroup: autoscaling +kind: HorizontalPodAutoscaler +version: v2beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +O/apis/autoscaling/v2beta2/watch/namespaces/{namespace}/horizontalpodautoscalers( +autoscaling_v2beta2watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead.*path#name of the HorizontalPodAutoscaler"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean + /apis/batch/ +batchget information of a group*getBatchAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/batch/v1/ +batch_v1get available resources*getBatchV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +/apis/batch/v1/cronjobs% +batch_v1%list or watch objects of kind CronJob*"listBatchV1CronJobForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.batch.v1.CronJobList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/apis/batch/v1/jobs% +batch_v1!list or watch objects of kind Job*listBatchV1JobForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JW +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.batch.v1.JobList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean\ +./apis/batch/v1/namespaces/{namespace}/cronjobs[% +batch_v1%list or watch objects of kind CronJob*listBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.batch.v1.CronJobList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +" +batch_v1create a CronJob*createBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B? += +;bodybody *+ +)#/definitions/io.k8s.api.batch.v1.CronJobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob +A +201: +8 +Created- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob +B +202; +9 +Accepted- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +*, +batch_v1delete collection of CronJob*(deleteBatchV1CollectionNamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +5/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}) +batch_v1read the specified CronJob*readBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JW +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 + +batch_v1replace the specified CronJob*replaceBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B? += +;bodybody *+ +)#/definitions/io.k8s.api.batch.v1.CronJobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob +A +201: +8 +Created- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +* +batch_v1delete a CronJob*deleteBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +B +batch_v1&partially update the specified CronJob*patchBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob +A +201: +8 +Created- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J4 +20".pathname of the CronJob"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string + +2027 +5 +Accepted) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +*, +batch_v1delete collection of Job*$deleteBatchV1CollectionNamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +1/apis/batch/v1/namespaces/{namespace}/jobs/{name}( +batch_v1read the specified Job*readBatchV1NamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JS +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 + +batch_v1replace the specified Job*replaceBatchV1NamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.batch.v1.JobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +* +batch_v1 delete a Job*deleteBatchV1NamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +B +batch_v1"partially update the specified Job*patchBatchV1NamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J0 +.,"*pathname of the Job"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +8/apis/batch/v1/namespaces/{namespace}/jobs/{name}/status +batch_v1 read status of the specified Job*readBatchV1NamespacedJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JS +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 + +batch_v1#replace status of the specified Job*!replaceBatchV1NamespacedJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.batch.v1.JobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +B +batch_v1,partially update status of the specified Job*patchBatchV1NamespacedJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.batch.v1.Job += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.batch.v1.Job + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J0 +.,"*pathname of the Job"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +/apis/batch/v1/watch/cronjobs& +batch_v1swatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.*'watchBatchV1CronJobListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +/apis/batch/v1/watch/jobs& +batch_v1owatch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.*#watchBatchV1JobListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +4/apis/batch/v1/watch/namespaces/{namespace}/cronjobs' +batch_v1swatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.*!watchBatchV1NamespacedCronJobList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +;/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}( +batch_v1watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchBatchV1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jL +x-kubernetes-group-version-kind)'group: batch +kind: CronJob +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ4 +20".pathname of the CronJob"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +0/apis/batch/v1/watch/namespaces/{namespace}/jobs' +batch_v1owatch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead.*watchBatchV1NamespacedJobList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +7/apis/batch/v1/watch/namespaces/{namespace}/jobs/{name}( +batch_v1watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchBatchV1NamespacedJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jH +x-kubernetes-group-version-kind%#group: batch +kind: Job +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ0 +.,"*pathname of the Job"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/batch/v1beta1/ + batch_v1beta1get available resources*getBatchV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +/apis/batch/v1beta1/cronjobs& + batch_v1beta1%list or watch objects of kind CronJob*'listBatchV1beta1CronJobForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.batch.v1beta1.CronJobList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean\ +3/apis/batch/v1beta1/namespaces/{namespace}/cronjobs\% + batch_v1beta1%list or watch objects of kind CronJob*!listBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.batch.v1beta1.CronJobList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +" + batch_v1beta1create a CronJob*#createBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +G +202@ +> +Accepted2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +*, + batch_v1beta1delete collection of CronJob*-deleteBatchV1beta1CollectionNamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +:/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}) + batch_v1beta1read the specified CronJob*!readBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 + + batch_v1beta1replace the specified CronJob*$replaceBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +* + batch_v1beta1delete a CronJob*#deleteBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +B + batch_v1beta1&partially update the specified CronJob*"patchBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J4 +20".pathname of the CronJob"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +A/apis/batch/v1beta1/namespaces/{namespace}/cronjobs/{name}/status + batch_v1beta1$read status of the specified CronJob*'readBatchV1beta1NamespacedCronJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 + + batch_v1beta1'replace status of the specified CronJob**replaceBatchV1beta1NamespacedCronJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJobB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +B + batch_v1beta10partially update status of the specified CronJob*(patchBatchV1beta1NamespacedCronJobStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J4 +20".pathname of the CronJob"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +"/apis/batch/v1beta1/watch/cronjobs& + batch_v1beta1swatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.*,watchBatchV1beta1CronJobListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +9/apis/batch/v1beta1/watch/namespaces/{namespace}/cronjobs' + batch_v1beta1swatch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead.*&watchBatchV1beta1NamespacedCronJobList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +@/apis/batch/v1beta1/watch/namespaces/{namespace}/cronjobs/{name}( + batch_v1beta1watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*"watchBatchV1beta1NamespacedCronJob2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jQ +x-kubernetes-group-version-kind.,group: batch +kind: CronJob +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ4 +20".pathname of the CronJob"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/certificates.k8s.io/ + certificatesget information of a group*getCertificatesAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/certificates.k8s.io/v1/ +certificates_v1get available resources*getCertificatesV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps^ +7/apis/certificates.k8s.io/v1/certificatesigningrequests]& +certificates_v17list or watch objects of kind CertificateSigningRequest*+listCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJt +Y +200R +P +OKJ +H +F#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +" + +certificates_v1"create a CertificateSigningRequest*-createCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BX +V +Tbodybody *D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +[ +202T +R +AcceptedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +*- +certificates_v1.delete collection of CertificateSigningRequest*7deleteCertificatesV1CollectionCertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +>/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}+ +certificates_v1,read the specified CertificateSigningRequest*+readCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jp +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 + +certificates_v1/replace the specified CertificateSigningRequest*.replaceCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BX +V +Tbodybody *D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +* +certificates_v1"delete a CertificateSigningRequest*-deleteCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +B +certificates_v18partially update the specified CertificateSigningRequest*,patchCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +JF +DB"@path%name of the CertificateSigningRequest"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +G/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/approval +certificates_v18read approval of the specified CertificateSigningRequest*3readCertificatesV1CertificateSigningRequestApproval2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jp +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 + +certificates_v1;replace approval of the specified CertificateSigningRequest*6replaceCertificatesV1CertificateSigningRequestApproval2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BX +V +Tbodybody *D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +B +certificates_v1Dpartially update approval of the specified CertificateSigningRequest*4patchCertificatesV1CertificateSigningRequestApproval2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +JF +DB"@path%name of the CertificateSigningRequest"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +E/apis/certificates.k8s.io/v1/certificatesigningrequests/{name}/status +certificates_v16read status of the specified CertificateSigningRequest*1readCertificatesV1CertificateSigningRequestStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jp +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 + +certificates_v19replace status of the specified CertificateSigningRequest*4replaceCertificatesV1CertificateSigningRequestStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BX +V +Tbodybody *D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +B +certificates_v1Bpartially update status of the specified CertificateSigningRequest*2patchCertificatesV1CertificateSigningRequestStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +U +200N +L +OKF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest +Z +201S +Q +CreatedF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +JF +DB"@path%name of the CertificateSigningRequest"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +=/apis/certificates.k8s.io/v1/watch/certificatesigningrequests' +certificates_v1watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead.*0watchCertificatesV1CertificateSigningRequestList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +D/apis/certificates.k8s.io/v1/watch/certificatesigningrequests/{name}( +certificates_v1watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*,watchCertificatesV1CertificateSigningRequest2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jl +x-kubernetes-group-version-kindIGgroup: certificates.k8s.io +kind: CertificateSigningRequest +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJF +DB"@path%name of the CertificateSigningRequest"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanX +[/apis/cluster.open-cluster-management.io/v1alpha1/namespaces/{namespace}/placementdecisionsW% +'clusterOpenClusterManagementIo_v1alpha1&list objects of kind PlacementDecision*ElistClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ} +b +200[ +Y +OKS +Q +O#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecisionList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +" + +'clusterOpenClusterManagementIo_v1alpha1create a PlacementDecision*GcreateClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlBa +_ +]bodybody *M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecisionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision +c +201\ +Z +CreatedO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision +d +202] +[ +AcceptedO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +*% +'clusterOpenClusterManagementIo_v1alpha1&delete collection of PlacementDecision*QdeleteClusterOpenClusterManagementIoV1alpha1CollectionNamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlB +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string- +b/apis/cluster.open-cluster-management.io/v1alpha1/namespaces/{namespace}/placementdecisions/{name}, +'clusterOpenClusterManagementIo_v1alpha1$read the specified PlacementDecision*EreadClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJy +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 + + +'clusterOpenClusterManagementIo_v1alpha1'replace the specified PlacementDecision*HreplaceClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlBa +_ +]bodybody *M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecisionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision +c +201\ +Z +CreatedO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +* +'clusterOpenClusterManagementIo_v1alpha1delete a PlacementDecision*GdeleteClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json:application/yamlBW +U +Sbodybody*E +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2B +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +O +200H +F +OK@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 +U +202N +L +Accepted@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2 + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +B +'clusterOpenClusterManagementIo_v1alpha10partially update the specified PlacementDecision*FpatchClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecision2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJy +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +J> +<:"8pathname of the PlacementDecision"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +i/apis/cluster.open-cluster-management.io/v1alpha1/namespaces/{namespace}/placementdecisions/{name}/status +'clusterOpenClusterManagementIo_v1alpha1.read status of the specified PlacementDecision*KreadClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecisionStatus2application/json2application/yaml:application/json:application/yamlB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJy +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 + + +'clusterOpenClusterManagementIo_v1alpha11replace status of the specified PlacementDecision*NreplaceClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecisionStatus2application/json2application/yaml:application/json:application/yamlBa +_ +]bodybody *M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecisionB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision +c +201\ +Z +CreatedO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +B +'clusterOpenClusterManagementIo_v1alpha1:partially update status of the specified PlacementDecision*LpatchClusterOpenClusterManagementIoV1alpha1NamespacedPlacementDecisionStatus2application/json2application/yaml:application/json-patch+json:application/merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJy +^ +200W +U +OKO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +J> +<:"8pathname of the PlacementDecision"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +D/apis/cluster.open-cluster-management.io/v1alpha1/placementdecisions& +'clusterOpenClusterManagementIo_v1alpha1&list objects of kind PlacementDecision*KlistClusterOpenClusterManagementIoV1alpha1PlacementDecisionForAllNamespaces2application/json2application/yaml:application/json:application/yamlJ} +b +200[ +Y +OKS +Q +O#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecisionList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jy +x-kubernetes-group-version-kindVTgroup: cluster.open-cluster-management.io +kind: PlacementDecision +version: v1alpha1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/coordination.k8s.io/ + coordinationget information of a group*getCoordinationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/coordination.k8s.io/v1/ +coordination_v1get available resources*getCoordinationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +#/apis/coordination.k8s.io/v1/leases& +coordination_v1#list or watch objects of kind Lease*'listCoordinationV1LeaseForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.coordination.v1.LeaseList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +:/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases\% +coordination_v1#list or watch objects of kind Lease*!listCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.coordination.v1.LeaseList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +" +coordination_v1create a Lease*#createCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.coordination.v1.LeaseB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease +G +202@ +> +Accepted2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +*, +coordination_v1delete collection of Lease*-deleteCoordinationV1CollectionNamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +A/apis/coordination.k8s.io/v1/namespaces/{namespace}/leases/{name}* +coordination_v1read the specified Lease*!readCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 + +coordination_v1replace the specified Lease*$replaceCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.coordination.v1.LeaseB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +* +coordination_v1delete a Lease*#deleteCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +B +coordination_v1$partially update the specified Lease*"patchCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J2 +0.",pathname of the Lease"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +)/apis/coordination.k8s.io/v1/watch/leases& +coordination_v1qwatch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.*,watchCoordinationV1LeaseListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +@/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases' +coordination_v1qwatch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead.*&watchCoordinationV1NamespacedLeaseList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +G/apis/coordination.k8s.io/v1/watch/namespaces/{namespace}/leases/{name}( +coordination_v1watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*"watchCoordinationV1NamespacedLease2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jX +x-kubernetes-group-version-kind53group: coordination.k8s.io +kind: Lease +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ2 +0.",pathname of the Lease"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/discovery.k8s.io/ + discoveryget information of a group*getDiscoveryAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/discovery.k8s.io/v1/ + discovery_v1get available resources*getDiscoveryV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +(/apis/discovery.k8s.io/v1/endpointslices& + discovery_v1+list or watch objects of kind EndpointSlice*,listDiscoveryV1EndpointSliceForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.discovery.v1.EndpointSliceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +?/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices]% + discovery_v1+list or watch objects of kind EndpointSlice*&listDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJe +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.discovery.v1.EndpointSliceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +" + discovery_v1create an EndpointSlice*(createDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSliceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice +L +202E +C +Accepted7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +*, + discovery_v1"delete collection of EndpointSlice*2deleteDiscoveryV1CollectionNamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +F/apis/discovery.k8s.io/v1/namespaces/{namespace}/endpointslices/{name}* + discovery_v1 read the specified EndpointSlice*&readDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ja +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 + + discovery_v1#replace the specified EndpointSlice*)replaceDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSliceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +* + discovery_v1delete an EndpointSlice*(deleteDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +B + discovery_v1,partially update the specified EndpointSlice*'patchDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J: +86"4pathname of the EndpointSlice"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +./apis/discovery.k8s.io/v1/watch/endpointslices' + discovery_v1ywatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.*1watchDiscoveryV1EndpointSliceListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +E/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices' + discovery_v1ywatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.*+watchDiscoveryV1NamespacedEndpointSliceList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +L/apis/discovery.k8s.io/v1/watch/namespaces/{namespace}/endpointslices/{name}( + discovery_v1watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*'watchDiscoveryV1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j] +x-kubernetes-group-version-kind:8group: discovery.k8s.io +kind: EndpointSlice +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ: +86"4pathname of the EndpointSlice"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/discovery.k8s.io/v1beta1/ +discovery_v1beta1get available resources*getDiscoveryV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +-/apis/discovery.k8s.io/v1beta1/endpointslices& +discovery_v1beta1+list or watch objects of kind EndpointSlice*1listDiscoveryV1beta1EndpointSliceForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jj +O +200H +F +OK@ +> +<#/definitions/io.k8s.api.discovery.v1beta1.EndpointSliceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean^ +D/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices]% +discovery_v1beta1+list or watch objects of kind EndpointSlice*+listDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJj +O +200H +F +OK@ +> +<#/definitions/io.k8s.api.discovery.v1beta1.EndpointSliceList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +" +discovery_v1beta1create an EndpointSlice*-createDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BN +L +Jbodybody *: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSliceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +K +200D +B +OK< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice +P +201I +G +Created< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice +Q +202J +H +Accepted< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +*, +discovery_v1beta1"delete collection of EndpointSlice*7deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +K/apis/discovery.k8s.io/v1beta1/namespaces/{namespace}/endpointslices/{name}+ +discovery_v1beta1 read the specified EndpointSlice*+readDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jf +K +200D +B +OK< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 + +discovery_v1beta1#replace the specified EndpointSlice*.replaceDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BN +L +Jbodybody *: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSliceB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +K +200D +B +OK< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice +P +201I +G +Created< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +* +discovery_v1beta1delete an EndpointSlice*-deleteDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +B +discovery_v1beta1,partially update the specified EndpointSlice*,patchDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +K +200D +B +OK< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice +P +201I +G +Created< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J: +86"4pathname of the EndpointSlice"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +3/apis/discovery.k8s.io/v1beta1/watch/endpointslices' +discovery_v1beta1ywatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.*6watchDiscoveryV1beta1EndpointSliceListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +J/apis/discovery.k8s.io/v1beta1/watch/namespaces/{namespace}/endpointslices' +discovery_v1beta1ywatch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead.*0watchDiscoveryV1beta1NamespacedEndpointSliceList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +Q/apis/discovery.k8s.io/v1beta1/watch/namespaces/{namespace}/endpointslices/{name}( +discovery_v1beta1watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*,watchDiscoveryV1beta1NamespacedEndpointSlice2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jb +x-kubernetes-group-version-kind?=group: discovery.k8s.io +kind: EndpointSlice +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ: +86"4pathname of the EndpointSlice"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/events.k8s.io/ +eventsget information of a group*getEventsAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/events.k8s.io/v1/ + events_v1get available resources*getEventsV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +/apis/events.k8s.io/v1/events% + events_v1#list or watch objects of kind Event*!listEventsV1EventForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.events.v1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean\ +4/apis/events.k8s.io/v1/namespaces/{namespace}/events\% + events_v1#list or watch objects of kind Event*listEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.events.v1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +" + events_v1create an Event*createEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.events.v1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.events.v1.Event +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.events.v1.Event +A +202: +8 +Accepted, +* +(#/definitions/io.k8s.api.events.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +*, + events_v1delete collection of Event*'deleteEventsV1CollectionNamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +;/apis/events.k8s.io/v1/namespaces/{namespace}/events/{name}) + events_v1read the specified Event*readEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JV +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.events.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 + + events_v1replace the specified Event*replaceEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B> +< +:bodybody ** +(#/definitions/io.k8s.api.events.v1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.events.v1.Event +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.events.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +* + events_v1delete an Event*deleteEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +B + events_v1$partially update the specified Event*patchEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +; +2004 +2 +OK, +* +(#/definitions/io.k8s.api.events.v1.Event +@ +2019 +7 +Created, +* +(#/definitions/io.k8s.api.events.v1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +#/apis/events.k8s.io/v1/watch/events& + events_v1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.*&watchEventsV1EventListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +:/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events' + events_v1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.* watchEventsV1NamespacedEventList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +A/apis/events.k8s.io/v1/watch/namespaces/{namespace}/events/{name}( + events_v1watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchEventsV1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jR +x-kubernetes-group-version-kind/-group: events.k8s.io +kind: Event +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/events.k8s.io/v1beta1/ +events_v1beta1get available resources*getEventsV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps& +"/apis/events.k8s.io/v1beta1/events& +events_v1beta1#list or watch objects of kind Event*&listEventsV1beta1EventForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.events.v1beta1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +9/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events\% +events_v1beta1#list or watch objects of kind Event* listEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.events.v1beta1.EventList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +" +events_v1beta1create an Event*"createEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.events.v1beta1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event +F +202? += +Accepted1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +*, +events_v1beta1delete collection of Event*,deleteEventsV1beta1CollectionNamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +@/apis/events.k8s.io/v1beta1/namespaces/{namespace}/events/{name}) +events_v1beta1read the specified Event* readEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 + +events_v1beta1replace the specified Event*#replaceEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.events.v1beta1.EventB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +* +events_v1beta1delete an Event*"deleteEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +B +events_v1beta1$partially update the specified Event*!patchEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +(/apis/events.k8s.io/v1beta1/watch/events& +events_v1beta1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.*+watchEventsV1beta1EventListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +?/apis/events.k8s.io/v1beta1/watch/namespaces/{namespace}/events' +events_v1beta1qwatch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.*%watchEventsV1beta1NamespacedEventList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +F/apis/events.k8s.io/v1beta1/watch/namespaces/{namespace}/events/{name}( +events_v1beta1watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*!watchEventsV1beta1NamespacedEvent2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jW +x-kubernetes-group-version-kind42group: events.k8s.io +kind: Event +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ2 +0.",pathname of the Event"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +#/apis/flowcontrol.apiserver.k8s.io/ +flowcontrolApiserverget information of a group*getFlowcontrolApiserverAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps ++/apis/flowcontrol.apiserver.k8s.io/v1beta1/ +flowcontrolApiserver_v1beta1get available resources**getFlowcontrolApiserverV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps] +6/apis/flowcontrol.apiserver.k8s.io/v1beta1/flowschemas]% +flowcontrolApiserver_v1beta1(list or watch objects of kind FlowSchema*)listFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJi +N +200G +E +OK? += +;#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +" +flowcontrolApiserver_v1beta1create a FlowSchema*+createFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +P +202I +G +Accepted; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +*- +flowcontrolApiserver_v1beta1delete collection of FlowSchema*5deleteFlowcontrolApiserverV1beta1CollectionFlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +=/apis/flowcontrol.apiserver.k8s.io/v1beta1/flowschemas/{name}+ +flowcontrolApiserver_v1beta1read the specified FlowSchema*)readFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 + +flowcontrolApiserver_v1beta1 replace the specified FlowSchema*,replaceFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +* +flowcontrolApiserver_v1beta1delete a FlowSchema*+deleteFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +B +flowcontrolApiserver_v1beta1)partially update the specified FlowSchema**patchFlowcontrolApiserverV1beta1FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +J7 +53"1pathname of the FlowSchema"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +D/apis/flowcontrol.apiserver.k8s.io/v1beta1/flowschemas/{name}/status +flowcontrolApiserver_v1beta1'read status of the specified FlowSchema*/readFlowcontrolApiserverV1beta1FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 + +flowcontrolApiserver_v1beta1*replace status of the specified FlowSchema*2replaceFlowcontrolApiserverV1beta1FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +B +flowcontrolApiserver_v1beta13partially update status of the specified FlowSchema*0patchFlowcontrolApiserverV1beta1FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta1 +J7 +53"1pathname of the FlowSchema"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string_ +F/apis/flowcontrol.apiserver.k8s.io/v1beta1/prioritylevelconfigurations_& +flowcontrolApiserver_v1beta18list or watch objects of kind PriorityLevelConfiguration*9listFlowcontrolApiserverV1beta1PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJy +^ +200W +U +OKO +M +K#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 +" + +flowcontrolApiserver_v1beta1#create a PriorityLevelConfiguration*;createFlowcontrolApiserverV1beta1PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B] +[ +Ybodybody *I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Z +200S +Q +OKK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration +_ +201X +V +CreatedK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration +` +202Y +W +AcceptedK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 +*- +flowcontrolApiserver_v1beta1/delete collection of PriorityLevelConfiguration*EdeleteFlowcontrolApiserverV1beta1CollectionPriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string. +M/apis/flowcontrol.apiserver.k8s.io/v1beta1/prioritylevelconfigurations/{name}- +flowcontrolApiserver_v1beta1-read the specified PriorityLevelConfiguration*9readFlowcontrolApiserverV1beta1PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ju +Z +200S +Q +OKK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 + +flowcontrolApiserver_v1beta10replace the specified PriorityLevelConfiguration*watchFlowcontrolApiserverV1beta1PriorityLevelConfigurationList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +S/apis/flowcontrol.apiserver.k8s.io/v1beta1/watch/prioritylevelconfigurations/{name}( +flowcontrolApiserver_v1beta1watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*:watchFlowcontrolApiserverV1beta1PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJG +EC"Apath&name of the PriorityLevelConfiguration"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean ++/apis/flowcontrol.apiserver.k8s.io/v1beta2/ +flowcontrolApiserver_v1beta2get available resources**getFlowcontrolApiserverV1beta2APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps] +6/apis/flowcontrol.apiserver.k8s.io/v1beta2/flowschemas]% +flowcontrolApiserver_v1beta2(list or watch objects of kind FlowSchema*)listFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJi +N +200G +E +OK? += +;#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +" +flowcontrolApiserver_v1beta2create a FlowSchema*+createFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +P +202I +G +Accepted; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +*- +flowcontrolApiserver_v1beta2delete collection of FlowSchema*5deleteFlowcontrolApiserverV1beta2CollectionFlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +=/apis/flowcontrol.apiserver.k8s.io/v1beta2/flowschemas/{name}+ +flowcontrolApiserver_v1beta2read the specified FlowSchema*)readFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 + +flowcontrolApiserver_v1beta2 replace the specified FlowSchema*,replaceFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +* +flowcontrolApiserver_v1beta2delete a FlowSchema*+deleteFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +B +flowcontrolApiserver_v1beta2)partially update the specified FlowSchema**patchFlowcontrolApiserverV1beta2FlowSchema2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +J7 +53"1pathname of the FlowSchema"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +D/apis/flowcontrol.apiserver.k8s.io/v1beta2/flowschemas/{name}/status +flowcontrolApiserver_v1beta2'read status of the specified FlowSchema*/readFlowcontrolApiserverV1beta2FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Je +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 + +flowcontrolApiserver_v1beta2*replace status of the specified FlowSchema*2replaceFlowcontrolApiserverV1beta2FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BM +K +Ibodybody *9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +B +flowcontrolApiserver_v1beta23partially update status of the specified FlowSchema*0patchFlowcontrolApiserverV1beta2FlowSchemaStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema +O +201H +F +Created; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jk +x-kubernetes-group-version-kindHFgroup: flowcontrol.apiserver.k8s.io +kind: FlowSchema +version: v1beta2 +J7 +53"1pathname of the FlowSchema"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string_ +F/apis/flowcontrol.apiserver.k8s.io/v1beta2/prioritylevelconfigurations_& +flowcontrolApiserver_v1beta28list or watch objects of kind PriorityLevelConfiguration*9listFlowcontrolApiserverV1beta2PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJy +^ +200W +U +OKO +M +K#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 +" + +flowcontrolApiserver_v1beta2#create a PriorityLevelConfiguration*;createFlowcontrolApiserverV1beta2PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B] +[ +Ybodybody *I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +Z +200S +Q +OKK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration +_ +201X +V +CreatedK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration +` +202Y +W +AcceptedK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 +*- +flowcontrolApiserver_v1beta2/delete collection of PriorityLevelConfiguration*EdeleteFlowcontrolApiserverV1beta2CollectionPriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string. +M/apis/flowcontrol.apiserver.k8s.io/v1beta2/prioritylevelconfigurations/{name}- +flowcontrolApiserver_v1beta2-read the specified PriorityLevelConfiguration*9readFlowcontrolApiserverV1beta2PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ju +Z +200S +Q +OKK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 + +flowcontrolApiserver_v1beta20replace the specified PriorityLevelConfiguration*watchFlowcontrolApiserverV1beta2PriorityLevelConfigurationList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +S/apis/flowcontrol.apiserver.k8s.io/v1beta2/watch/prioritylevelconfigurations/{name}( +flowcontrolApiserver_v1beta2watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*:watchFlowcontrolApiserverV1beta2PriorityLevelConfiguration2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j{ +x-kubernetes-group-version-kindXVgroup: flowcontrol.apiserver.k8s.io +kind: PriorityLevelConfiguration +version: v1beta2 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJG +EC"Apath&name of the PriorityLevelConfiguration"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/metrics.k8s.io/ +metricsget information of a group*getMetricsAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJP +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroupRhttps +/apis/metrics.k8s.io/v1beta1/ +metrics_v1beta1get available resources*getMetricsV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJW +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceListRhttps' +8/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods& +metrics_v1beta1list objects of kind PodMetrics*&listMetricsV1beta1NamespacedPodMetrics2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JY +W +200P +N +OKH +F +D#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsListRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: metrics.k8s.io +kind: PodMetrics +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +?/apis/metrics.k8s.io/v1beta1/namespaces/{namespace}/pods/{name} +metrics_v1beta1read the specified PodMetrics*&readMetricsV1beta1NamespacedPodMetrics2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JU +S +200L +J +OKD +B +@#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsRhttpsj +x-kubernetes-actionget +j] +x-kubernetes-group-version-kind:8group: metrics.k8s.io +kind: PodMetrics +version: v1beta1 +J7 +53"1pathname of the PodMetrics"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +"/apis/metrics.k8s.io/v1beta1/nodes& +metrics_v1beta1 list objects of kind NodeMetrics*listMetricsV1beta1NodeMetrics2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JZ +X +200Q +O +OKI +G +E#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsListRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: metrics.k8s.io +kind: NodeMetrics +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +)/apis/metrics.k8s.io/v1beta1/nodes/{name} +metrics_v1beta1read the specified NodeMetrics*readMetricsV1beta1NodeMetrics2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JV +T +200M +K +OKE +C +A#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.NodeMetricsRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: metrics.k8s.io +kind: NodeMetrics +version: v1beta1 +J8 +64"2pathname of the NodeMetrics"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +!/apis/metrics.k8s.io/v1beta1/pods& +metrics_v1beta1list objects of kind PodMetrics*,listMetricsV1beta1PodMetricsForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JY +W +200P +N +OKH +F +D#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsListRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: metrics.k8s.io +kind: PodMetrics +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/networking.k8s.io/ + +networkingget information of a group*getNetworkingAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/networking.k8s.io/v1/ + networking_v1get available resources*getNetworkingV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps\ +)/apis/networking.k8s.io/v1/ingressclasses\% + networking_v1*list or watch objects of kind IngressClass*listNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJe +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.networking.v1.IngressClassList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +" + networking_v1create an IngressClass*createNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.networking.v1.IngressClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass +L +202E +C +Accepted7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +*, + networking_v1!delete collection of IngressClass*(deleteNetworkingV1CollectionIngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +0/apis/networking.k8s.io/v1/ingressclasses/{name}) + networking_v1read the specified IngressClass*readNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ja +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 + + networking_v1"replace the specified IngressClass*replaceNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.networking.v1.IngressClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +* + networking_v1delete an IngressClass*deleteNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +B + networking_v1+partially update the specified IngressClass*patchNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +J9 +75"3pathname of the IngressClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +$/apis/networking.k8s.io/v1/ingresses& + networking_v1%list or watch objects of kind Ingress*'listNetworkingV1IngressForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.networking.v1.IngressList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +;/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses\% + networking_v1%list or watch objects of kind Ingress*!listNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.networking.v1.IngressList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +" + networking_v1create an Ingress*#createNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.networking.v1.IngressB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +G +202@ +> +Accepted2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +*, + networking_v1delete collection of Ingress*-deleteNetworkingV1CollectionNamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +B/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}* + networking_v1read the specified Ingress*!readNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 + + networking_v1replace the specified Ingress*$replaceNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.networking.v1.IngressB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +* + networking_v1delete an Ingress*#deleteNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +B + networking_v1&partially update the specified Ingress*"patchNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J4 +20".pathname of the Ingress"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +I/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}/status + networking_v1$read status of the specified Ingress*'readNetworkingV1NamespacedIngressStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J\ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 + + networking_v1'replace status of the specified Ingress**replaceNetworkingV1NamespacedIngressStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BD +B +@bodybody *0 +.#/definitions/io.k8s.api.networking.v1.IngressB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +B + networking_v10partially update status of the specified Ingress*(patchNetworkingV1NamespacedIngressStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +A +200: +8 +OK2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress +F +201? += +Created2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J4 +20".pathname of the Ingress"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string] +A/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies]% + networking_v1+list or watch objects of kind NetworkPolicy*'listNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJf +K +200D +B +OK< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +" + networking_v1create a NetworkPolicy*)createNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicyB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +M +202F +D +Accepted8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +*, + networking_v1"delete collection of NetworkPolicy*3deleteNetworkingV1CollectionNamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +H/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}* + networking_v1 read the specified NetworkPolicy*'readNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 + + networking_v1#replace the specified NetworkPolicy**replaceNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicyB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +* + networking_v1delete a NetworkPolicy*)deleteNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +B + networking_v1,partially update the specified NetworkPolicy*(patchNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J: +86"4pathname of the NetworkPolicy"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +O/apis/networking.k8s.io/v1/namespaces/{namespace}/networkpolicies/{name}/status + networking_v1*read status of the specified NetworkPolicy*-readNetworkingV1NamespacedNetworkPolicyStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 + + networking_v1-replace status of the specified NetworkPolicy*0replaceNetworkingV1NamespacedNetworkPolicyStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicyB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +B + networking_v16partially update status of the specified NetworkPolicy*.patchNetworkingV1NamespacedNetworkPolicyStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J: +86"4pathname of the NetworkPolicy"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +*/apis/networking.k8s.io/v1/networkpolicies& + networking_v1+list or watch objects of kind NetworkPolicy*-listNetworkingV1NetworkPolicyForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jf +K +200D +B +OK< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +//apis/networking.k8s.io/v1/watch/ingressclasses& + networking_v1xwatch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead.*!watchNetworkingV1IngressClassList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +6/apis/networking.k8s.io/v1/watch/ingressclasses/{name}' + networking_v1watch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchNetworkingV1IngressClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j] +x-kubernetes-group-version-kind:8group: networking.k8s.io +kind: IngressClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ9 +75"3pathname of the IngressClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +*/apis/networking.k8s.io/v1/watch/ingresses& + networking_v1swatch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.*,watchNetworkingV1IngressListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +A/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses' + networking_v1swatch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead.*&watchNetworkingV1NamespacedIngressList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +H/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/ingresses/{name}( + networking_v1watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*"watchNetworkingV1NamespacedIngress2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jX +x-kubernetes-group-version-kind53group: networking.k8s.io +kind: Ingress +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ4 +20".pathname of the Ingress"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +G/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies' + networking_v1ywatch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.*,watchNetworkingV1NamespacedNetworkPolicyList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +N/apis/networking.k8s.io/v1/watch/namespaces/{namespace}/networkpolicies/{name}( + networking_v1watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*(watchNetworkingV1NamespacedNetworkPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ: +86"4pathname of the NetworkPolicy"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +0/apis/networking.k8s.io/v1/watch/networkpolicies' + networking_v1ywatch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead.*2watchNetworkingV1NetworkPolicyListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: networking.k8s.io +kind: NetworkPolicy +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/node.k8s.io/ +nodeget information of a group*getNodeAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/node.k8s.io/v1/ +node_v1get available resources*getNodeV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps[ +#/apis/node.k8s.io/v1/runtimeclasses[% +node_v1*list or watch objects of kind RuntimeClass*listNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.node.v1.RuntimeClassList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +" +node_v1create a RuntimeClass*createNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.node.v1.RuntimeClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass +F +202? += +Accepted1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +*, +node_v1!delete collection of RuntimeClass*"deleteNodeV1CollectionRuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +*/apis/node.k8s.io/v1/runtimeclasses/{name}( +node_v1read the specified RuntimeClass*readNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 + +node_v1"replace the specified RuntimeClass*replaceNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.node.v1.RuntimeClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +* +node_v1delete a RuntimeClass*deleteNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +B +node_v1+partially update the specified RuntimeClass*patchNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +J9 +75"3pathname of the RuntimeClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +)/apis/node.k8s.io/v1/watch/runtimeclasses& +node_v1xwatch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.*watchNodeV1RuntimeClassList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +0/apis/node.k8s.io/v1/watch/runtimeclasses/{name}' +node_v1watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchNodeV1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jW +x-kubernetes-group-version-kind42group: node.k8s.io +kind: RuntimeClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ9 +75"3pathname of the RuntimeClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/node.k8s.io/v1beta1/ + node_v1beta1get available resources*getNodeV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps\ +(/apis/node.k8s.io/v1beta1/runtimeclasses\% + node_v1beta1*list or watch objects of kind RuntimeClass*listNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.node.v1beta1.RuntimeClassList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +" + node_v1beta1create a RuntimeClass*createNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BH +F +Dbodybody *4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass +J +201C +A +Created6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass +K +202D +B +Accepted6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +*, + node_v1beta1!delete collection of RuntimeClass*'deleteNodeV1beta1CollectionRuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +//apis/node.k8s.io/v1beta1/runtimeclasses/{name}) + node_v1beta1read the specified RuntimeClass*readNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 + + node_v1beta1"replace the specified RuntimeClass*replaceNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BH +F +Dbodybody *4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass +J +201C +A +Created6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +* + node_v1beta1delete a RuntimeClass*deleteNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +B + node_v1beta1+partially update the specified RuntimeClass*patchNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +E +200> +< +OK6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass +J +201C +A +Created6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +J9 +75"3pathname of the RuntimeClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +./apis/node.k8s.io/v1beta1/watch/runtimeclasses& + node_v1beta1xwatch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead.* watchNodeV1beta1RuntimeClassList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +5/apis/node.k8s.io/v1beta1/watch/runtimeclasses/{name}' + node_v1beta1watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchNodeV1beta1RuntimeClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j\ +x-kubernetes-group-version-kind97group: node.k8s.io +kind: RuntimeClass +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ9 +75"3pathname of the RuntimeClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean + /apis/policy/ +policyget information of a group*getPolicyAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/policy/v1/ + policy_v1get available resources*getPolicyV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps] +;/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets]% + policy_v11list or watch objects of kind PodDisruptionBudget*)listPolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +" + policy_v1create a PodDisruptionBudget*+createPolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget +O +202H +F +Accepted: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +*, + policy_v1(delete collection of PodDisruptionBudget*5deletePolicyV1CollectionNamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +B/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}+ + policy_v1&read the specified PodDisruptionBudget*)readPolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 + + policy_v1)replace the specified PodDisruptionBudget*,replacePolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +* + policy_v1delete a PodDisruptionBudget*+deletePolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +B + policy_v12partially update the specified PodDisruptionBudget**patchPolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J@ +><":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +I/apis/policy/v1/namespaces/{namespace}/poddisruptionbudgets/{name}/status + policy_v10read status of the specified PodDisruptionBudget*/readPolicyV1NamespacedPodDisruptionBudgetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 + + policy_v13replace status of the specified PodDisruptionBudget*2replacePolicyV1NamespacedPodDisruptionBudgetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +B + policy_v1<":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +$/apis/policy/v1/poddisruptionbudgets& + policy_v11list or watch objects of kind PodDisruptionBudget*/listPolicyV1PodDisruptionBudgetForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +A/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets' + policy_v1watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.*.watchPolicyV1NamespacedPodDisruptionBudgetList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +H/apis/policy/v1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}( + policy_v1watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.**watchPolicyV1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ@ +><":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +*/apis/policy/v1/watch/poddisruptionbudgets' + policy_v1watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.*4watchPolicyV1PodDisruptionBudgetListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jY +x-kubernetes-group-version-kind64group: policy +kind: PodDisruptionBudget +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/policy/v1beta1/ +policy_v1beta1get available resources*getPolicyV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps^ +@/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets]% +policy_v1beta11list or watch objects of kind PodDisruptionBudget*.listPolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +" +policy_v1beta1create a PodDisruptionBudget*0createPolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BQ +O +Mbodybody *= +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget +S +201L +J +Created? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget +T +202M +K +Accepted? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +*, +policy_v1beta1(delete collection of PodDisruptionBudget*:deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +G/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}+ +policy_v1beta1&read the specified PodDisruptionBudget*.readPolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ji +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 + +policy_v1beta1)replace the specified PodDisruptionBudget*1replacePolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BQ +O +Mbodybody *= +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget +S +201L +J +Created? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +* +policy_v1beta1delete a PodDisruptionBudget*0deletePolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +B +policy_v1beta12partially update the specified PodDisruptionBudget*/patchPolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget +S +201L +J +Created? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J@ +><":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +N/apis/policy/v1beta1/namespaces/{namespace}/poddisruptionbudgets/{name}/status +policy_v1beta10read status of the specified PodDisruptionBudget*4readPolicyV1beta1NamespacedPodDisruptionBudgetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ji +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 + +policy_v1beta13replace status of the specified PodDisruptionBudget*7replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BQ +O +Mbodybody *= +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget +S +201L +J +Created? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +B +policy_v1beta1<":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +)/apis/policy/v1beta1/poddisruptionbudgets& +policy_v1beta11list or watch objects of kind PodDisruptionBudget*4listPolicyV1beta1PodDisruptionBudgetForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean] +(/apis/policy/v1beta1/podsecuritypolicies\% +policy_v1beta1/list or watch objects of kind PodSecurityPolicy*"listPolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJk +P +200I +G +OKA +? +=#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicyList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +" +policy_v1beta1create a PodSecurityPolicy*$createPolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BO +M +Kbodybody *; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicyB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy +Q +201J +H +Created= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy +R +202K +I +Accepted= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +*, +policy_v1beta1&delete collection of PodSecurityPolicy*.deletePolicyV1beta1CollectionPodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +//apis/policy/v1beta1/podsecuritypolicies/{name}* +policy_v1beta1$read the specified PodSecurityPolicy*"readPolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jg +L +200E +C +OK= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 + +policy_v1beta1'replace the specified PodSecurityPolicy*%replacePolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BO +M +Kbodybody *; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicyB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy +Q +201J +H +Created= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +* +policy_v1beta1delete a PodSecurityPolicy*$deletePolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy +R +202K +I +Accepted= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +B +policy_v1beta10partially update the specified PodSecurityPolicy*#patchPolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +L +200E +C +OK= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy +Q +201J +H +Created= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +J> +<:"8pathname of the PodSecurityPolicy"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string( +F/apis/policy/v1beta1/watch/namespaces/{namespace}/poddisruptionbudgets' +policy_v1beta1watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.*3watchPolicyV1beta1NamespacedPodDisruptionBudgetList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +M/apis/policy/v1beta1/watch/namespaces/{namespace}/poddisruptionbudgets/{name}( +policy_v1beta1watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*/watchPolicyV1beta1NamespacedPodDisruptionBudget2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ@ +><":pathname of the PodDisruptionBudget"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +//apis/policy/v1beta1/watch/poddisruptionbudgets' +policy_v1beta1watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead.*9watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: policy +kind: PodDisruptionBudget +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +./apis/policy/v1beta1/watch/podsecuritypolicies' +policy_v1beta1}watch individual changes to a list of PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead.*'watchPolicyV1beta1PodSecurityPolicyList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +5/apis/policy/v1beta1/watch/podsecuritypolicies/{name}' +policy_v1beta1watch changes to an object of kind PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*#watchPolicyV1beta1PodSecurityPolicy2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j\ +x-kubernetes-group-version-kind97group: policy +kind: PodSecurityPolicy +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ> +<:"8pathname of the PodSecurityPolicy"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean + /apis/rbac.authorization.k8s.io/ +rbacAuthorizationget information of a group*getRbacAuthorizationAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +#/apis/rbac.authorization.k8s.io/v1/ +rbacAuthorization_v1get available resources*"getRbacAuthorizationV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps] +6/apis/rbac.authorization.k8s.io/v1/clusterrolebindings]% +rbacAuthorization_v10list or watch objects of kind ClusterRoleBinding*)listRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJe +J +200C +A +OK; +9 +7#/definitions/io.k8s.api.rbac.v1.ClusterRoleBindingList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +" +rbacAuthorization_v1create a ClusterRoleBinding*+createRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBindingB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding +L +202E +C +Accepted7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +*- +rbacAuthorization_v1'delete collection of ClusterRoleBinding*5deleteRbacAuthorizationV1CollectionClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +=/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/{name}+ +rbacAuthorization_v1%read the specified ClusterRoleBinding*)readRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ja +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 + +rbacAuthorization_v1(replace the specified ClusterRoleBinding*,replaceRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BI +G +Ebodybody *5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBindingB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +* +rbacAuthorization_v1delete a ClusterRoleBinding*+deleteRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +B +rbacAuthorization_v11partially update the specified ClusterRoleBinding**patchRbacAuthorizationV1ClusterRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +F +200? += +OK7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding +K +201D +B +Created7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jk +x-kubernetes-group-version-kindHFgroup: rbac.authorization.k8s.io +kind: ClusterRoleBinding +version: v1 +J? +=;"9pathname of the ClusterRoleBinding"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +//apis/rbac.authorization.k8s.io/v1/clusterroles\% +rbacAuthorization_v1)list or watch objects of kind ClusterRole*"listRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.rbac.v1.ClusterRoleList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +" +rbacAuthorization_v1create a ClusterRole*$createRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.rbac.v1.ClusterRoleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole +E +202> +< +Accepted0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +*, +rbacAuthorization_v1 delete collection of ClusterRole*.deleteRbacAuthorizationV1CollectionClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +6/apis/rbac.authorization.k8s.io/v1/clusterroles/{name}* +rbacAuthorization_v1read the specified ClusterRole*"readRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 + +rbacAuthorization_v1!replace the specified ClusterRole*%replaceRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.rbac.v1.ClusterRoleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +* +rbacAuthorization_v1delete a ClusterRole*$deleteRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +B +rbacAuthorization_v1*partially update the specified ClusterRole*#patchRbacAuthorizationV1ClusterRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: ClusterRole +version: v1 +J8 +64"2pathname of the ClusterRole"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string^ +F/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings]% +rbacAuthorization_v1)list or watch objects of kind RoleBinding*,listRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.rbac.v1.RoleBindingList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +" +rbacAuthorization_v1create a RoleBinding*.createRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.rbac.v1.RoleBindingB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding +E +202> +< +Accepted0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +*, +rbacAuthorization_v1 delete collection of RoleBinding*8deleteRbacAuthorizationV1CollectionNamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +M/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/rolebindings/{name}+ +rbacAuthorization_v1read the specified RoleBinding*,readRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JZ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 + +rbacAuthorization_v1!replace the specified RoleBinding*/replaceRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BB +@ +>bodybody *. +,#/definitions/io.k8s.api.rbac.v1.RoleBindingB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +* +rbacAuthorization_v1delete a RoleBinding*.deleteRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +B +rbacAuthorization_v1*partially update the specified RoleBinding*-patchRbacAuthorizationV1NamespacedRoleBinding2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +? +2008 +6 +OK0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding +D +201= +; +Created0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +J8 +64"2pathname of the RoleBinding"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string] +?/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles\% +rbacAuthorization_v1"list or watch objects of kind Role*%listRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJW +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.rbac.v1.RoleList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +" +rbacAuthorization_v1 create a Role*'createRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.rbac.v1.RoleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.rbac.v1.Role += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.rbac.v1.Role +> +2027 +5 +Accepted) +' +%#/definitions/io.k8s.api.rbac.v1.Role + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +*, +rbacAuthorization_v1delete collection of Role*1deleteRbacAuthorizationV1CollectionNamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +F/apis/rbac.authorization.k8s.io/v1/namespaces/{namespace}/roles/{name}* +rbacAuthorization_v1read the specified Role*%readRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JS +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.rbac.v1.Role + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 + +rbacAuthorization_v1replace the specified Role*(replaceRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*B; +9 +7bodybody *' +%#/definitions/io.k8s.api.rbac.v1.RoleB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.rbac.v1.Role += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.rbac.v1.Role + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +* +rbacAuthorization_v1 delete a Role*'deleteRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +B +rbacAuthorization_v1#partially update the specified Role*&patchRbacAuthorizationV1NamespacedRole2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +8 +2001 +/ +OK) +' +%#/definitions/io.k8s.api.rbac.v1.Role += +2016 +4 +Created) +' +%#/definitions/io.k8s.api.rbac.v1.Role + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +J1 +/-"+pathname of the Role"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +//apis/rbac.authorization.k8s.io/v1/rolebindings& +rbacAuthorization_v1)list or watch objects of kind RoleBinding*2listRbacAuthorizationV1RoleBindingForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*J^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.rbac.v1.RoleBindingList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jd +x-kubernetes-group-version-kindA?group: rbac.authorization.k8s.io +kind: RoleBinding +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean& +(/apis/rbac.authorization.k8s.io/v1/roles& +rbacAuthorization_v1"list or watch objects of kind Role*+listRbacAuthorizationV1RoleForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*JW +< +2005 +3 +OK- ++ +)#/definitions/io.k8s.api.rbac.v1.RoleList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j] +x-kubernetes-group-version-kind:8group: rbac.authorization.k8s.io +kind: Role +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' + +OK8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass +M +202F +D +Accepted8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +*, + scheduling_v1"delete collection of PriorityClass*)deleteSchedulingV1CollectionPriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +1/apis/scheduling.k8s.io/v1/priorityclasses/{name}) + scheduling_v1 read the specified PriorityClass*readSchedulingV1PriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 + + scheduling_v1#replace the specified PriorityClass* replaceSchedulingV1PriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +* + scheduling_v1delete a PriorityClass*deleteSchedulingV1PriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +B + scheduling_v1,partially update the specified PriorityClass*patchSchedulingV1PriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +J: +86"4pathname of the PriorityClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +0/apis/scheduling.k8s.io/v1/watch/priorityclasses& + scheduling_v1ywatch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead.*"watchSchedulingV1PriorityClassList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +7/apis/scheduling.k8s.io/v1/watch/priorityclasses/{name}' + scheduling_v1watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchSchedulingV1PriorityClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j^ +x-kubernetes-group-version-kind;9group: scheduling.k8s.io +kind: PriorityClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ: +86"4pathname of the PriorityClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/storage.k8s.io/ +storageget information of a group*getStorageAPIGroup2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJi +N +200G +E +OK? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +401 + + UnauthorizedRhttps +/apis/storage.k8s.io/v1/ + +storage_v1get available resources*getStorageV1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps[ +"/apis/storage.k8s.io/v1/csidrivers[% + +storage_v1'list or watch objects of kind CSIDriver*listStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ_ +D +200= +; +OK5 +3 +1#/definitions/io.k8s.api.storage.v1.CSIDriverList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +" + +storage_v1create a CSIDriver*createStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.storage.v1.CSIDriverB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver +F +202? += +Accepted1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +*, + +storage_v1delete collection of CSIDriver*"deleteStorageV1CollectionCSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +)/apis/storage.k8s.io/v1/csidrivers/{name}( + +storage_v1read the specified CSIDriver*readStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J[ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 + + +storage_v1replace the specified CSIDriver*replaceStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BC +A +?bodybody */ +-#/definitions/io.k8s.api.storage.v1.CSIDriverB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +* + +storage_v1delete a CSIDriver*deleteStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver +F +202? += +Accepted1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +B + +storage_v1(partially update the specified CSIDriver*patchStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +@ +2009 +7 +OK1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver +E +201> +< +Created1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +J6 +42"0pathname of the CSIDriver"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string[ + /apis/storage.k8s.io/v1/csinodes[% + +storage_v1%list or watch objects of kind CSINode*listStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJ] +B +200; +9 +OK3 +1 +/#/definitions/io.k8s.api.storage.v1.CSINodeList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +" + +storage_v1create a CSINode*createStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.storage.v1.CSINodeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +*, + +storage_v1delete collection of CSINode* deleteStorageV1CollectionCSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string( +'/apis/storage.k8s.io/v1/csinodes/{name}( + +storage_v1read the specified CSINode*readStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*JY +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 + + +storage_v1replace the specified CSINode*replaceStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BA +? +=bodybody *- ++#/definitions/io.k8s.api.storage.v1.CSINodeB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +* + +storage_v1delete a CSINode*deleteStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode +D +202= +; +Accepted/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +B + +storage_v1&partially update the specified CSINode*patchStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +> +2007 +5 +OK/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode +C +201< +: +Created/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +J4 +20".pathname of the CSINode"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string& +,/apis/storage.k8s.io/v1/csistoragecapacities& + +storage_v10list or watch objects of kind CSIStorageCapacity*/listStorageV1CSIStorageCapacityForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.storage.v1.CSIStorageCapacityList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean^ +C/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities]% + +storage_v10list or watch objects of kind CSIStorageCapacity*)listStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJh +M +200F +D +OK> +< +:#/definitions/io.k8s.api.storage.v1.CSIStorageCapacityList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +" + +storage_v1create a CSIStorageCapacity*+createStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacityB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity +O +202H +F +Accepted: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +*, + +storage_v1'delete collection of CSIStorageCapacity*5deleteStorageV1CollectionNamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string+ +J/apis/storage.k8s.io/v1/namespaces/{namespace}/csistoragecapacities/{name}+ + +storage_v1%read the specified CSIStorageCapacity*)readStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jd +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 + + +storage_v1(replace the specified CSIStorageCapacity*,replaceStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BL +J +Hbodybody *8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacityB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +* + +storage_v1delete a CSIStorageCapacity*+deleteStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +B + +storage_v11partially update the specified CSIStorageCapacity**patchStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +I +200B +@ +OK: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity +N +201G +E +Created: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J? +=;"9pathname of the CSIStorageCapacity"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +&/apis/storage.k8s.io/v1/storageclasses[% + +storage_v1*list or watch objects of kind StorageClass*listStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.StorageClassList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +" + +storage_v1create a StorageClass*createStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BF +D +Bbodybody *2 +0#/definitions/io.k8s.api.storage.v1.StorageClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass +H +201A +? +Created4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass +I +202B +@ +Accepted4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +*, + +storage_v1!delete collection of StorageClass*%deleteStorageV1CollectionStorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string) +-/apis/storage.k8s.io/v1/storageclasses/{name}) + +storage_v1read the specified StorageClass*readStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*J^ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 + + +storage_v1"replace the specified StorageClass*replaceStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BF +D +Bbodybody *2 +0#/definitions/io.k8s.api.storage.v1.StorageClassB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass +H +201A +? +Created4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +* + +storage_v1delete a StorageClass*deleteStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass +I +202B +@ +Accepted4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +B + +storage_v1+partially update the specified StorageClass*patchStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +C +200< +: +OK4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass +H +201A +? +Created4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +J9 +75"3pathname of the StorageClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string\ +)/apis/storage.k8s.io/v1/volumeattachments\% + +storage_v1.list or watch objects of kind VolumeAttachment*listStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJf +K +200D +B +OK< +: +8#/definitions/io.k8s.api.storage.v1.VolumeAttachmentList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +" + +storage_v1create a VolumeAttachment*createStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachmentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +M +202F +D +Accepted8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +*, + +storage_v1%delete collection of VolumeAttachment*)deleteStorageV1CollectionVolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +JO +MKIquery-If 'true', then the output is pretty printed."pretty2string* +0/apis/storage.k8s.io/v1/volumeattachments/{name}) + +storage_v1#read the specified VolumeAttachment*readStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 + + +storage_v1&replace the specified VolumeAttachment* replaceStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachmentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +* + +storage_v1delete a VolumeAttachment*deleteStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +M +202F +D +Accepted8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +B + +storage_v1/partially update the specified VolumeAttachment*patchStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +J= +;9"7pathname of the VolumeAttachment"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string +7/apis/storage.k8s.io/v1/volumeattachments/{name}/status + +storage_v1-read status of the specified VolumeAttachment*#readStorageV1VolumeAttachmentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Jb +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 + + +storage_v10replace status of the specified VolumeAttachment*&replaceStorageV1VolumeAttachmentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BJ +H +Fbodybody *6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachmentB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +B + +storage_v19partially update status of the specified VolumeAttachment*$patchStorageV1VolumeAttachmentStatus2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +G +200@ +> +OK8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment +L +201E +C +Created8 +6 +4#/definitions/io.k8s.api.storage.v1.VolumeAttachment + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +J= +;9"7pathname of the VolumeAttachment"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +(/apis/storage.k8s.io/v1/watch/csidrivers& + +storage_v1uwatch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead.*watchStorageV1CSIDriverList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +//apis/storage.k8s.io/v1/watch/csidrivers/{name}' + +storage_v1watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchStorageV1CSIDriver2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jW +x-kubernetes-group-version-kind42group: storage.k8s.io +kind: CSIDriver +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ6 +42"0pathname of the CSIDriver"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +&/apis/storage.k8s.io/v1/watch/csinodes& + +storage_v1swatch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead.*watchStorageV1CSINodeList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +-/apis/storage.k8s.io/v1/watch/csinodes/{name}' + +storage_v1watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchStorageV1CSINode2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jU +x-kubernetes-group-version-kind20group: storage.k8s.io +kind: CSINode +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ4 +20".pathname of the CSINode"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +2/apis/storage.k8s.io/v1/watch/csistoragecapacities' + +storage_v1~watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.*4watchStorageV1CSIStorageCapacityListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +I/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities' + +storage_v1~watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.*.watchStorageV1NamespacedCSIStorageCapacityList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +P/apis/storage.k8s.io/v1/watch/namespaces/{namespace}/csistoragecapacities/{name}( + +storage_v1watch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.**watchStorageV1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j` +x-kubernetes-group-version-kind=;group: storage.k8s.io +kind: CSIStorageCapacity +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ? +=;"9pathname of the CSIStorageCapacity"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +,/apis/storage.k8s.io/v1/watch/storageclasses& + +storage_v1xwatch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead.*watchStorageV1StorageClassList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +3/apis/storage.k8s.io/v1/watch/storageclasses/{name}' + +storage_v1watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchStorageV1StorageClass2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +jZ +x-kubernetes-group-version-kind75group: storage.k8s.io +kind: StorageClass +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ9 +75"3pathname of the StorageClass"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean' +//apis/storage.k8s.io/v1/watch/volumeattachments& + +storage_v1|watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead.*"watchStorageV1VolumeAttachmentList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +6/apis/storage.k8s.io/v1/watch/volumeattachments/{name}' + +storage_v1watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*watchStorageV1VolumeAttachment2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +j^ +x-kubernetes-group-version-kind;9group: storage.k8s.io +kind: VolumeAttachment +version: v1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ= +;9"7pathname of the VolumeAttachment"name*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean +/apis/storage.k8s.io/v1beta1/ +storage_v1beta1get available resources*getStorageV1beta1APIResources2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json:application/yaml:#application/vnd.kubernetes.protobufJp +U +200N +L +OKF +D +B#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList + +401 + + UnauthorizedRhttps' +1/apis/storage.k8s.io/v1beta1/csistoragecapacities& +storage_v1beta10list or watch objects of kind CSIStorageCapacity*4listStorageV1beta1CSIStorageCapacityForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacityList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean^ +H/apis/storage.k8s.io/v1beta1/namespaces/{namespace}/csistoragecapacities^% +storage_v1beta10list or watch objects of kind CSIStorageCapacity*.listStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*B +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerB +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanJm +R +200K +I +OKC +A +?#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacityList + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionlist +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +" +storage_v1beta1create a CSIStorageCapacity*0createStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BQ +O +Mbodybody *= +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacityB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity +S +201L +J +Created? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity +T +202M +K +Accepted? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpost +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +*- +storage_v1beta1'delete collection of CSIStorageCapacity*:deleteStorageV1beta1CollectionNamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringB + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringB +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringB +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringB +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJg +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj* +x-kubernetes-actiondeletecollection +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string, +O/apis/storage.k8s.io/v1beta1/namespaces/{namespace}/csistoragecapacities/{name}, +storage_v1beta1%read the specified CSIStorageCapacity*.readStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*Ji +N +200G +E +OK? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionget +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 + +storage_v1beta1(replace the specified CSIStorageCapacity*1replaceStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BQ +O +Mbodybody *= +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacityB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint." fieldManager2stringJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity +S +201L +J +Created? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionput +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +* +storage_v1beta1delete a CSIStorageCapacity*0deleteStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:*/*BT +R +Pbodybody*B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptionsB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryThe duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately."gracePeriodSeconds2integerB +queryDeprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both."orphanDependents2booleanB +queryWhether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground."propagationPolicy2stringJ +L +200E +C +OK= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status +R +202K +I +Accepted= +; +9#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Status + +401 + + UnauthorizedRhttpsj +x-kubernetes-action delete +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +B +storage_v1beta11partially update the specified CSIStorageCapacity*/patchStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf:application/json-patch+json:application/merge-patch+json:&application/strategic-merge-patch+json:application/apply-patch+yamlBN +L +Jbodybody *: +8#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.PatchB +queryWhen present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed"dryRun2stringB +queryfieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch)." fieldManager2stringB +queryForce is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests."force2booleanJ +N +200G +E +OK? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity +S +201L +J +Created? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionpatch +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J? +=;"9pathname of the CSIStorageCapacity"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2string' +7/apis/storage.k8s.io/v1beta1/watch/csistoragecapacities' +storage_v1beta1~watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.*9watchStorageV1beta1CSIStorageCapacityListForAllNamespaces2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean( +N/apis/storage.k8s.io/v1beta1/watch/namespaces/{namespace}/csistoragecapacities' +storage_v1beta1~watch individual changes to a list of CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead.*3watchStorageV1beta1NamespacedCSIStorageCapacityList2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj# +x-kubernetes-action  +watchlist +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2boolean) +U/apis/storage.k8s.io/v1beta1/watch/namespaces/{namespace}/csistoragecapacities/{name}( +storage_v1beta1watch changes to an object of kind CSIStorageCapacity. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.*/watchStorageV1beta1NamespacedCSIStorageCapacity2application/json2application/yaml2#application/vnd.kubernetes.protobuf2application/json;stream=watch20application/vnd.kubernetes.protobuf;stream=watch:*/*Jk +P +200I +G +OKA +? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent + +401 + + UnauthorizedRhttpsj +x-kubernetes-actionwatch +je +x-kubernetes-group-version-kindB@group: storage.k8s.io +kind: CSIStorageCapacity +version: v1beta1 +J +queryallowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored."allowWatchBookmarks2booleanJ +   query The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + +This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications."continue2stringJ +query\A selector to restrict the list of returned objects by their fields. Defaults to everything." fieldSelector2stringJ +query\A selector to restrict the list of returned objects by their labels. Defaults to everything." labelSelector2stringJ + + + + +query +limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + +The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned."limit2integerJ? +=;"9pathname of the CSIStorageCapacity"name*stringJ` +^\"Zpath:object name and auth scope, such as for teams and projects" namespace*stringJO +MKIquery-If 'true', then the output is pretty printed."pretty2stringJ +queryresourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersion2stringJ +queryresourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + +Defaults to unset"resourceVersionMatch2stringJ +querypTimeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity."timeoutSeconds2integerJ +queryWatch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion."watch2booleanH +/logs/>< +logs*logFileListHandlerJ + +401 + + UnauthorizedRhttps +/logs/{logpath}o8 +logs*logFileHandlerJ + +401 + + UnauthorizedRhttpsJ3 +1/"-pathpath to the log"logpath*string +/openid/v1/jwks/ +openid\get service account issuer OpenID JSON Web Key Set (contains public token verification keys)*#getServiceAccountIssuerOpenIDKeyset2application/jwk-set+jsonJ7 + +200 + +OK +  +string + +401 + + UnauthorizedRhttps + /version/ +versionget the code version*getCodeVersion2application/json:application/jsonJ` +E +200> +< +OK6 +4 +2#/definitions/io.k8s.apimachinery.pkg.version.Info + +401 + + UnauthorizedRhttpsJR + +0dev.summerwind.actions.v1alpha1.RunnerDeployment"FRunnerDeployment is the Schema for the runnerdeployments API. test-leo +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec"BRunnerDeploymentSpec defines the desired state of RunnerDeploymenttemplate +object + + effectiveTime date-time"EffectiveTime is the time the upstream controller requested to sync Replicas. It is usually populated by the webhook-based autoscaler via HRA. The value is inherited to RunnerRepicaSet(s) and used to prevent ephemeral runners from unnecessarily recreated. + +replicas + +selector"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. + +template +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec".RunnerSpec defines the desired state of Runner +object + +affinity"1Affinity is a group of affinity scheduling rules. +object +) + nodeAffinity)"5Describes node affinity scheduling rules for the pod. +object( + +/preferredDuringSchedulingIgnoredDuringExecution"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. +array +"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). +preferenceweight +object + + +preference "?A node selector term, associated with the corresponding weight. +object + +matchExpressions"6A list of node selector requirements by node's labels. +array +"wA node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +? +key8"+The label key that the selector applies to. +string + +operator"tRepresents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. +string + +values"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. +array +  +string + + matchFields"6A list of node selector requirements by node's fields. +array +"wA node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +? +key8"+The label key that the selector applies to. +string + +operator"tRepresents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. +string + +values"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. +array +  +string +v +weightlint32"WWeight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. +integer + +.requiredDuringSchedulingIgnoredDuringExecution"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.nodeSelectorTerms +object + +nodeSelectorTerms" matches that of any node on which a pod of the set of pods is running topologyKey +object + + labelSelector "9A label query over a set of resources, in this case pods. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + +namespaceSelector "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. This field is beta-level and is only honored when PodAffinityNamespaceSelector feature is enabled. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + + +namespaces"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace" +array +  +string + + topologyKey"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. +string +F +podAntiAffinityF"}Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). +objectE +# +/preferredDuringSchedulingIgnoredDuringExecution""The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. +array +"vThe weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)podAffinityTermweight +object + +podAffinityTerm"HRequired. A pod affinity term, associated with the corresponding weight. topologyKey +object + + labelSelector "9A label query over a set of resources, in this case pods. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + +namespaceSelector "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. This field is beta-level and is only honored when PodAffinityNamespaceSelector feature is enabled. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + + +namespaces"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace" +array +  +string + + topologyKey"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. +string +u +weightkint32"Vweight associated with matching the corresponding podAffinityTerm, in the range 1-100. +integer +" +.requiredDuringSchedulingIgnoredDuringExecution!"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. +array +"Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running topologyKey +object + + labelSelector "9A label query over a set of resources, in this case pods. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + +namespaceSelector "A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. This field is beta-level and is only honored when PodAffinityNamespaceSelector feature is enabled. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + + +namespaces"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace" +array +  +string + + topologyKey"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. +string +, +automountServiceAccountToken  +boolean +՝ + +containersŝ +array +"AA single application container that you want to run within a pod.name +object؜ + +args"Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +envFrom "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array +":EnvFromSource represents the source of a set of ConfigMaps +object + + configMapRef"The ConfigMap to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean +n +prefixd"WAn optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. +string + + secretRef"The Secret to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +D +optional8"*Specify whether the Secret must be defined +boolean + +image"Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images +string +& + lifecycle&"lActions that the management system should take in response to container lifecycle events. Cannot be updated. +object% + + postStart"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +preStop"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + + livenessProbe "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +name"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. +string + + +ports +"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default "0.0.0.0" address inside a container will be accessible from the network. Cannot be updated. +array +">ContainerPort represents a network port in a single container. containerPort +object + + containerPortwint32"bNumber of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. +integer +A +hostIP7"*What host IP to bind the external port to. +string + +hostPortint32"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. +integer + +name"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +string +Y +protocolM"@Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + +! +readinessProbe "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + + resources"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +0 +securityContext0"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/ +object. + +allowPrivilegeEscalation"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. +boolean + + capabilities"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. +object +c +add\"Added capabilities +array; +9",Capability represent POSIX capabilities type +string +f +drop^"Removed capabilities +array; +9",Capability represent POSIX capabilities type +string + + +privileged"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. +boolean + + procMount"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. +string + +readOnlyRootFilesystem"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. +boolean + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +object +Q +levelH";Level is SELinux level label that applies to the container. +string +P +roleH";Role is a SELinux role label that applies to the container. +string +P +typeH";Type is a SELinux type label that applies to the container. +string +P +userH";User is a SELinux user label that applies to the container. +string + +seccompProfile"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. +string + +windowsOptions "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string +# + startupProbe#"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array +"JvolumeDevice describes a mapping of a raw block device within a container. +devicePathname +object +l + +devicePath^"QdevicePath is the path inside of the container that the device will be mapped to. +string +S +nameK">name must match the name of a persistentVolumeClaim in the pod +string + + volumeMounts "HPod volumes to mount into the container's filesystem. Cannot be updated. +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string + + dnsConfig"_PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. +object + + nameservers"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. +array +  +string + +options"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy. +array +"9PodDNSConfigOption defines DNS resolver options of a pod. +object6 + +name" Required. +string + +value  +string + +searches"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed. +array +  +string + + dockerEnabled  +boolean + + dockerEnv +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + + dockerMTUint64 +integer +# +dockerRegistryMirror  +string + +dockerVolumeMounts +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + +dockerdContainerResources"AResourceRequirements describes the compute resource requirements. +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +, +dockerdWithinRunnerContainer  +boolean +" +enableServiceLinks  +boolean +" + +enterprisej^[^/]+$ +string + +env +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +envFrom +array +":EnvFromSource represents the source of a set of ConfigMaps +object + + configMapRef"The ConfigMap to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean +n +prefixd"WAn optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. +string + + secretRef"The Secret to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +D +optional8"*Specify whether the Secret must be defined +boolean + + ephemeral  +boolean + +ephemeralContainersؚ +arrayɚ +Ś"An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. + To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. + This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate.name +object + +args"Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +envFrom "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array +":EnvFromSource represents the source of a set of ConfigMaps +object + + configMapRef"The ConfigMap to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean +n +prefixd"WAn optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. +string + + secretRef"The Secret to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +D +optional8"*Specify whether the Secret must be defined +boolean +i +image`"SDocker image name. More info: https://kubernetes.io/docs/concepts/containers/images +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images +string +% + lifecycle%"2Lifecycle is not allowed for ephemeral containers. +object% + + postStart"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +preStop"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + + livenessProbe"0Probes are not allowed for ephemeral containers. +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +name"Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers. +string + +ports"/Ports are not allowed for ephemeral containers. +array +">ContainerPort represents a network port in a single container. containerPort +object + + containerPortwint32"bNumber of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. +integer +A +hostIP7"*What host IP to bind the external port to. +string + +hostPortint32"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. +integer + +name"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +string +Y +protocolM"@Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe"0Probes are not allowed for ephemeral containers. +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + + resources"zResources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod. +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +0 +securityContext0"Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. +object. + +allowPrivilegeEscalation"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. +boolean + + capabilities"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. +object +c +add\"Added capabilities +array; +9",Capability represent POSIX capabilities type +string +f +drop^"Removed capabilities +array; +9",Capability represent POSIX capabilities type +string + + +privileged"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. +boolean + + procMount"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. +string + +readOnlyRootFilesystem"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. +boolean + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +object +Q +levelH";Level is SELinux level label that applies to the container. +string +P +roleH";Role is a SELinux role label that applies to the container. +string +P +typeH";Type is a SELinux type label that applies to the container. +string +P +userH";User is a SELinux user label that applies to the container. +string + +seccompProfile"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. +string + +windowsOptions "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string + + startupProbe"0Probes are not allowed for ephemeral containers. +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +targetContainerName"If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec. + The container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined. +string + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array +"JvolumeDevice describes a mapping of a raw block device within a container. +devicePathname +object +l + +devicePath^"QdevicePath is the path inside of the container that the device will be mapped to. +string +S +nameK">name must match the name of a persistentVolumeClaim in the pod +string + + volumeMounts "Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated. +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string + +group  +string + + hostAliases +array +"oHostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file. +object +L + hostnames?"#Hostnames for the above IP address. +array +  +string +5 +ip/""IP address of the host file entry. +string + +image  +string +c +imagePullPolicyP"CPullPolicy describes a policy for if/when to pull a container image +string + +imagePullSecrets +array +"sLocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +ٝ +initContainersŝ +array +"AA single application container that you want to run within a pod.name +object؜ + +args"Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +envFrom "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array +":EnvFromSource represents the source of a set of ConfigMaps +object + + configMapRef"The ConfigMap to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean +n +prefixd"WAn optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. +string + + secretRef"The Secret to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +D +optional8"*Specify whether the Secret must be defined +boolean + +image"Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images +string +& + lifecycle&"lActions that the management system should take in response to container lifecycle events. Cannot be updated. +object% + + postStart"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +preStop"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + + livenessProbe "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +name"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. +string + + +ports +"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default "0.0.0.0" address inside a container will be accessible from the network. Cannot be updated. +array +">ContainerPort represents a network port in a single container. containerPort +object + + containerPortwint32"bNumber of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. +integer +A +hostIP7"*What host IP to bind the external port to. +string + +hostPortint32"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. +integer + +name"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +string +Y +protocolM"@Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + +! +readinessProbe "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + + resources"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +0 +securityContext0"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/ +object. + +allowPrivilegeEscalation"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. +boolean + + capabilities"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. +object +c +add\"Added capabilities +array; +9",Capability represent POSIX capabilities type +string +f +drop^"Removed capabilities +array; +9",Capability represent POSIX capabilities type +string + + +privileged"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. +boolean + + procMount"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. +string + +readOnlyRootFilesystem"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. +boolean + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +object +Q +levelH";Level is SELinux level label that applies to the container. +string +P +roleH";Role is a SELinux role label that applies to the container. +string +P +typeH";Type is a SELinux type label that applies to the container. +string +P +userH";User is a SELinux user label that applies to the container. +string + +seccompProfile"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. +string + +windowsOptions "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string +# + startupProbe#"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array +"JvolumeDevice describes a mapping of a raw block device within a container. +devicePathname +object +l + +devicePath^"QdevicePath is the path inside of the container that the device will be mapped to. +string +S +nameK">name must match the name of a persistentVolumeClaim in the pod +string + + volumeMounts "HPod volumes to mount into the container's filesystem. Cannot be updated. +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string +$ +labels +array +  +string ++ + nodeSelector +  +string +object +$ + organizationj^[^/]+$ +string +( + +repositoryj ^[^/]+/[^/]+$ +string + + resources"AResourceRequirements describes the compute resource requirements. +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +runtimeClassName"RuntimeClassName is the container runtime configuration that containers should run under. More info: https://kubernetes.io/docs/concepts/containers/runtime-class +string +1 +securityContext1"PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. +object/ + +fsGroupint64"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: + 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- + If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows. +integer + +fsGroupChangePolicy"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. Note that this field cannot be set when spec.os.name is windows. +string + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. +object +Q +levelH";Level is SELinux level label that applies to the container. +string +P +roleH";Role is a SELinux role label that applies to the container. +string +P +typeH";Type is a SELinux type label that applies to the container. +string +P +userH";User is a SELinux user label that applies to the container. +string + +seccompProfile"zThe seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. +string + +supplementalGroups"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. +array +int64 +integer + +sysctls"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows. +array +"+Sysctl defines a kernel parameter to be setnamevalue +objectb +. +name&"Name of a property to set +string +0 +value'"Value of a property to set +string + +windowsOptions "The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string +! +serviceAccountName  +string +ܝ +sidecarContainersŝ +array +"AA single application container that you want to run within a pod.name +object؜ + +args"Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array +"AEnvVar represents an environment variable present in a Container.name +object +N +nameF"9Name of the environment variable. Must be a C_IDENTIFIER. +string + +value"Variable references $(VAR_NAME) are expanded using the previously defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "". +string + + valueFrom"RSource for the environment variable's value. Cannot be used if value is not empty. +object + +configMapKeyRef"Selects a key of a ConfigMap.key +object +& +key"The key to select. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean + +fieldRef"Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + + secretKeyRef"0Selects a key of a secret in the pod's namespacekey +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +envFrom "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array +":EnvFromSource represents the source of a set of ConfigMaps +object + + configMapRef"The ConfigMap to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean +n +prefixd"WAn optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. +string + + secretRef"The Secret to select from +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +D +optional8"*Specify whether the Secret must be defined +boolean + +image"Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images +string +& + lifecycle&"lActions that the management system should take in response to container lifecycle events. Cannot be updated. +object% + + postStart"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +preStop"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + + tcpSocket"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + + livenessProbe "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +name"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. +string + + +ports +"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default "0.0.0.0" address inside a container will be accessible from the network. Cannot be updated. +array +">ContainerPort represents a network port in a single container. containerPort +object + + containerPortwint32"bNumber of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. +integer +A +hostIP7"*What host IP to bind the external port to. +string + +hostPortint32"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. +integer + +name"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +string +Y +protocolM"@Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + +! +readinessProbe "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + + resources"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +0 +securityContext0"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/ +object. + +allowPrivilegeEscalation"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. +boolean + + capabilities"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. +object +c +add\"Added capabilities +array; +9",Capability represent POSIX capabilities type +string +f +drop^"Removed capabilities +array; +9",Capability represent POSIX capabilities type +string + + +privileged"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. +boolean + + procMount"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. +string + +readOnlyRootFilesystem"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. +boolean + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +object +Q +levelH";Level is SELinux level label that applies to the container. +string +P +roleH";Role is a SELinux role label that applies to the container. +string +P +typeH";Type is a SELinux type label that applies to the container. +string +P +userH";User is a SELinux user label that applies to the container. +string + +seccompProfile"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. +string + +windowsOptions "The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string +# + startupProbe#"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +object + +exec""Exec specifies the action to take. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc"}GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.port +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + If this is not specified, the default behavior is defined by gRPC. +string + +httpGet".HTTPGet specifies the http request to perform.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array +">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string +7 +path/""Path to access on the HTTP server. +string + +port"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + +R +schemeH";Scheme to use for connecting to the host. Defaults to HTTP. +string + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer + + tcpSocket"3TCPSocket specifies an action involving a TCP port.port +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.% +x-kubernetes-int-or-stringtrue + + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array +"JvolumeDevice describes a mapping of a raw block device within a container. +devicePathname +object +l + +devicePath^"QdevicePath is the path inside of the container that the device will be mapped to. +string +S +nameK">name must match the name of a persistentVolumeClaim in the pod +string + + volumeMounts "HPod volumes to mount into the container's filesystem. Cannot be updated. +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string +4 +terminationGracePeriodSecondsint64 +integer + + + tolerations + +array + + +"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . +object + +effect"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. +string + +key"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. +string + +operator"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. +string + +tolerationSecondsint64"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. +integer + +value"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. +string + +topologySpreadConstraints +array +"XTopologySpreadConstraint specifies how to spread matching pods among the given topology.maxSkew topologyKeywhenUnsatisfiable +object + + + labelSelector "LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + +maxSkewint32"MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 1/1/0: | zone1 | zone2 | zone3 | | P | P | | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 1/1/1; scheduling it onto zone1(zone2) would make the ActualSkew(2-0) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed. +integer + + topologyKey"TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a "bucket", and try to put balanced number of pods into each bucket. It's a required field. +string + +whenUnsatisfiable"WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, but giving higher precedence to topologies that would help reduce the skew. A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assignment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field. +string + + volumeMounts +array +"@VolumeMount describes a mounting of a Volume within a container. mountPathname +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + +volumeSizeLimitjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +" +volumeStorageMedium  +string + +volumes +array +"[Volume represents a named volume in a pod that may be accessed by any container in the pod.name +object + + +awsElasticBlockStore +"AWSElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstorevolumeID +object + +fsType"Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore TODO: how do we prevent errors in the filesystem from compromising the machine +string + + partitionint32"The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as "1". Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty). +integer + +readOnly"Specify "true" to force and set the ReadOnly property in VolumeMounts to "true". If omitted, the default is "false". More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore +boolean + +volumeID"Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore +string + + azureDisk"TAzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.diskNamediskURI +object +K + cachingMode<"/Host Caching mode: None, Read Only, Read Write. +string +F +diskName:"-The Name of the data disk in the blob storage +string +A +diskURI6")The URI the data disk in the blob storage +string + +fsType"Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string + +kind"Expected values Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared +string +x +readOnlyl"^Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + azureFile"WAzureFile represents an Azure File Service mount on the host and bind mount to the pod. +secretName shareName +object +x +readOnlyl"^Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +^ + +secretNameP"Cthe name of secret that contains Azure Storage Account Name and Key +string +$ + shareName" +Share Name +string + + +cephfs +"JCephFS represents a Ceph FS mount on the host that shares a pod's lifetimemonitors +object + +monitors"}Required: Monitors is a collection of Ceph monitors More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it +array +  +string +e +path]"POptional: Used as the mounted root, rather than the full Ceph tree, default is / +string + +readOnly"Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it +boolean + + +secretFile"Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it +string + + secretRef"Optional: SecretRef is reference to the authentication secret for User, default is empty. More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string + +user"Optional: User is the rados user name, default is admin More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it +string + +cinder"Cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.mdvolumeID +object + +fsType"Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://examples.k8s.io/mysql-cinder-pd/README.md +string + +readOnly"Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://examples.k8s.io/mysql-cinder-pd/README.md +boolean + + secretRef"WOptional: points to a secret object containing parameters used to connect to OpenStack. +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string + +volumeIDz"mvolume id used to identify the volume in cinder. More info: https://examples.k8s.io/mysql-cinder-pd/README.md +string + + configMap"AConfigMap represents a configMap that should populate this volume +object + + defaultModeint32"Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +items "If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array +",Maps a string key to a path within a volume.keypath +object +' +key "The key to project. +string + +modeint32"Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"The relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +S +optionalG"9Specify whether the ConfigMap or its keys must be defined +boolean + +csi +"~CSI (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature).driver +object + +driver"Driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster. +string + +fsType"Filesystem type to mount. Ex. "ext4", "xfs", "ntfs". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply. +string + +nodePublishSecretRef"NodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed. +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +m +readOnlya"SSpecifies a read-only configuration for the volume. Defaults to false (read/write). +boolean + +volumeAttributes"VolumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values. +  +string +object + + downwardAPI"RDownwardAPI represents downward API about the pod that should populate this volume +object + + defaultModeint32"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +items "+Items is a list of downward API volume file +array + "XDownwardAPIVolumeFile represents information to create the file containing the pod fieldpath +object + +fieldRef"aRequired: Selects a field of the pod: only annotations, labels, name and namespace are supported. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +modeint32"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..' +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + +emptyDir"EmptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir +object + +medium"What type of storage medium should back this directory. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir +string + + sizeLimit"Total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydirjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +@ + ephemeral@"Ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. + Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity tracking are needed, c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through a PersistentVolumeClaim (see EphemeralVolumeSource for more information on the connection between this volume type and PersistentVolumeClaim). + Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. + Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. + A pod can use both types of ephemeral volumes and persistent volumes at the same time. +object7 +7 +volumeClaimTemplate7"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long). + An existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster. + This field is read-only and no changes will be made by Kubernetes to the PVC after it has been created. + Required, must not be nil.spec +object/ + +metadata"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string +, +spec,"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here. +object* + + accessModes"AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 +array +  +string + + +dataSource"This field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field.kindname +object + +apiGroup"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. +string +B +kind:"-Kind is the type of resource being referenced +string +B +name:"-Name is the name of resource being referenced +string + + dataSourceRef "Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Alpha) Using this field requires the AnyVolumeDataSource feature gate to be enabled.kindname +object + +apiGroup"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. +string +B +kind:"-Kind is the type of resource being referenced +string +B +name:"-Name is the name of resource being referenced +string + + resources "Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +selector"3A label query over volumes to consider for binding. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +array +"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object +F +key?"2key is the label key that the selector applies to. +string + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object + +storageClassName"Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 +string + + +volumeMode"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. +string +j + +volumeName\"OVolumeName is the binding reference to the PersistentVolume backing this claim. +string + +fc"pFC represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod. +object + +fsType"Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. TODO: how do we prevent errors in the filesystem from compromising the machine +string +: +lun3int32"Optional: FC target lun number +integer + +readOnlyv"hOptional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +T + +targetWWNsF"*Optional: FC target worldwide names (WWNs) +array +  +string + +wwids"Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously. +array +  +string + + +flexVolume"hFlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.driver +object +O +driverE"8Driver is the name of the driver to use for this volume. +string + +fsType"Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". The default filesystem depends on FlexVolume script. +string +O +optionsD"'Optional: Extra command options if any. +  +string +object + +readOnlyv"hOptional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + secretRef"Optional: SecretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts. +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string + +flocker"Flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running +object + + datasetNamey"lName of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated +string +_ + datasetUUIDP"CUUID of the dataset. This is unique identifier of a Flocker dataset +string + +gcePersistentDisk +"GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdiskpdName +object + +fsType"Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk TODO: how do we prevent errors in the filesystem from compromising the machine +string + + partitionint32"The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as "1". Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +integer + +pdName"Unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +string + +readOnly"ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +boolean + +gitRepo"GitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. +repository +object + + directory"Target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. +string +) + +repository"Repository URL +string +@ +revision4"'Commit hash for the specified revision. +string + + glusterfs"Glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md endpointspath +object + + endpoints"EndpointsName is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +path{"nPath is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +readOnly"ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +boolean + +hostPath"HostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath --- TODO(jonesdl) We need to restrict who can use host directory mounts and who can/can not mount host directories as read/write.path +object + +path"Path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath +string + +type|"oType for HostPath Volume Defaults to "" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath +string + +iscsi"ISCSI represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.mdiqnlun targetPortal +object +V +chapAuthDiscoveryA"3whether support iSCSI Discovery CHAP authentication +boolean +R +chapAuthSession?"1whether support iSCSI Session CHAP authentication +boolean + +fsType"Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi TODO: how do we prevent errors in the filesystem from compromising the machine +string + + initiatorName"Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. +string +0 +iqn)"Target iSCSI Qualified Name. +string +n +iscsiInterface\"OiSCSI Interface Name that uses an iSCSI transport. Defaults to 'default' (tcp). +string +4 +lun-int32"iSCSI Target Lun number. +integer + +portals"iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +array +  +string +k +readOnly_"QReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. +boolean + + secretRef"9CHAP Secret for iSCSI target and initiator authentication +object + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string + + targetPortal"iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +string + +name"Volume's name. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string + +nfs"NFS represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfspathserver +object + +pathx"kPath that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs +string + +readOnly"ReadOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs +boolean + +server"zServer is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs +string + +persistentVolumeClaim"PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims claimName +object + + claimName"ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims +string +Y +readOnlyM"?Will force the ReadOnly setting in VolumeMounts. Default false. +boolean + +photonPersistentDisk"pPhotonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machinepdID +object + +fsType"Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string +I +pdIDA"4ID that identifies Photon Controller persistent disk +string + +portworxVolume"YPortworxVolume represents a portworx volume attached and mounted on kubelets host machinevolumeID +object + +fsType"FSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs". Implicitly inferred to be "ext4" if unspecified. +string +x +readOnlyl"^Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +G +volumeID;".VolumeID uniquely identifies a Portworx volume +string +4 + projected4"DItems for all in one resources secrets, configmaps, and downward API +object3 + + defaultModeint32"Mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer +0 +sources0"list of volume projections +array/ +/"HProjection that may be projected along with other supported volume types +object. + + configMap "/information about the configMap data to project +object + +items "If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array +",Maps a string key to a path within a volume.keypath +object +' +key "The key to project. +string + +modeint32"Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"The relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +S +optionalG"9Specify whether the ConfigMap or its keys must be defined +boolean + + downwardAPI"1information about the downwardAPI data to project +object + +items ")Items is a list of DownwardAPIVolume file +array + "XDownwardAPIVolumeFile represents information to create the file containing the pod fieldpath +object + +fieldRef"aRequired: Selects a field of the pod: only annotations, labels, name and namespace are supported. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string + +modeint32"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..' +string + +resourceFieldRef"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported.resource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor"ESpecifies the output format of the exposed resources, defaults to "1"jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +5 +resource)"Required: resource to select +string + +secret ",information about the secret data to project +object + +items "If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array +",Maps a string key to a path within a volume.keypath +object +' +key "The key to project. +string + +modeint32"Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"The relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'. +string + +name"Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean + +serviceAccountToken"9information about the serviceAccountToken data to projectpath +object + +audience"Audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. +string + +expirationSecondsint64"ExpirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes. +integer +h +path`"SPath is the path relative to the mount point of the file to project the token into. +string + +quobyte"KQuobyte represents a Quobyte mount on the host that shares a pod's lifetimeregistryvolume +object +G +group>"1Group to map volume access to Default is no group +string + +readOnlyv"hReadOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false. +boolean + +registry"Registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes +string + +tenant"Tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin +string +Q +userI"#/definitions/dev.summerwind.actions.v1alpha1.RunnerDeployment + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsv +x-kubernetes-group-version-kindSQ- group: actions.summerwind.dev + kind: RunnerDeploymentList + version: v1alpha1 + + + io.argoproj.v1alpha1.AnalysisRunspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specmetrics +object + +args +array +name +object + +name  +string + +value  +string + + valueFrom +object +@ +fieldRef4 fieldPath +object + + fieldPath  +string +T + secretKeyRefDkeyname +object) + +key  +string + +name  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string + +metrics +array +nameprovider +object +A +consecutiveErrorLimit(% +x-kubernetes-int-or-stringtrue + +1 +count(% +x-kubernetes-int-or-stringtrue + + +failureCondition  +string +8 + failureLimit(% +x-kubernetes-int-or-stringtrue + += +inconclusiveLimit(% +x-kubernetes-int-or-stringtrue + + + initialDelay  +string + +interval  +string + +name  +string + +provider +object + + +cloudWatchmetricDataQueries +object + +interval  +string + +metricDataQueries +array + +object + + +expression  +string + +id  +string + +label  +string + + +metricStat +object + +metric +object +V + +dimensionsH +array; +9 +object+ + +name  +string + +value  +string + + +metricName  +string + + namespace  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + +stat  +string + +unit  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + + +returnData  +boolean +P +datadogEquery +object/ + +interval  +string + +query  +string +H +graphite< +object. + +address  +string + +query  +string +H +influxdb< +object. + +profile  +string + +query  +string + +jobspec +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spectemplate +object +, +activeDeadlineSecondsint64 +integer +# + backoffLimitint32 +integer + +completionMode  +string +" + completionsint32 +integer + +manualSelector  +boolean +" + parallelismint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +suspend  +boolean + +template +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spec +containers +object +, +activeDeadlineSecondsint64 +integer + +affinity +object + + nodeAffinity +object + +/preferredDuringSchedulingIgnoredDuringExecution +array + +preferenceweight +object + + +preference +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecutionnodeSelectorTerms +object + +nodeSelectorTerms +array + +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + podAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +podAntiAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string +, +automountServiceAccountToken  +boolean +0 + +containers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + + dnsConfig +object +) + nameservers +array +  +string +S +optionsH +array; +9 +object+ + +name  +string + +value  +string +& +searches +array +  +string + + dnsPolicy  +string +" +enableServiceLinks  +boolean +1 +ephemeralContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +" +targetContainerName  +string +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string +h + hostAliasesY +arrayL +J +object< +' + hostnames +array +  +string + +ip  +string + +hostIPC  +boolean + + hostNetwork  +boolean + +hostPID  +boolean + +hostname  +string +F +imagePullSecrets2 +array% +# +object + +name  +string +0 +initContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + +nodeName  +string +P + nodeSelector@ +  +string +object" +x-kubernetes-map-type atomic + +0 +os*name +object + +name  +string + +overhead +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +preemptionPolicy  +string + +priorityint32 +integer + +priorityClassName  +string +] +readinessGatesK +array> +< conditionType +object + + conditionType  +string + + restartPolicy  +string + +runtimeClassName  +string + + schedulerName  +string + +securityContext +object + +fsGroupint64 +integer +" +fsGroupChangePolicy  +string +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string +8 +supplementalGroups" +array +int64 +integer +b +sysctlsW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + +serviceAccount  +string +! +serviceAccountName  +string +! +setHostnameAsFQDN  +boolean +% +shareProcessNamespace  +boolean + + subdomain  +string +4 +terminationGracePeriodSecondsint64 +integer + + tolerations +array + +object + +effect  +string + +key  +string + +operator  +string +( +tolerationSecondsint64 +integer + +value  +string + +topologySpreadConstraints +array +maxSkew topologyKeywhenUnsatisfiable +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +maxSkewint32 +integer +! + +minDomainsint32 +integer + + topologyKey  +string + +whenUnsatisfiable  +stringB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap + += +volumes2/ +$x-kubernetes-preserve-unknown-fieldstrue + +. +ttlSecondsAfterFinishedint32 +integer + +kayentaaddress applicationcanaryConfigNameconfigurationAccountNamemetricsAccountNamescopesstorageAccountName threshold +object + +address  +string + + application  +string + +canaryConfigName  +string +' +configurationAccountName  +string +! +metricsAccountName  +string + +scopes +array + controlScopeexperimentScopename +object + + controlScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +experimentScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +name  +string +! +storageAccountName  +string +k + threshold^marginalpass +object> + +marginalint64 +integer + +passint64 +integer +P +newRelicDquery +object. + +profile  +string + +query  +string +J + +prometheus< +object. + +address  +string + +query  +string +I + wavefront< +object. + +address  +string + +query  +string + +weburl +object + +body  +string +` +headersU +arrayH +Fkeyvalue +object* + +key  +string + +value  +string + +insecure  +boolean + +jsonPath  +string + +method  +string +% +timeoutSecondsint64 +integer + +url  +string + +successCondition  +string + + terminate  +boolean + +status phase +object + + dryRunSummary +object + +countint32 +integer + +errorint32 +integer + +failedint32 +integer +# + inconclusiveint32 +integer +! + +successfulint32 +integer + +message  +string + + metricResults +array +namephase +object +' +consecutiveErrorint32 +integer + +countint32 +integer + +dryRun  +boolean + +errorint32 +integer + +failedint32 +integer +# + inconclusiveint32 +integer + + measurements +array +phase +object +$ + +finishedAt date-time +string + +message  +string +' +metadata +  +string +object + +phase  +string +" +resumeAt date-time +string +# + startedAt date-time +string + +value  +string + +message  +string +' +metadata +  +string +object + +name  +string + +phase  +string +! + +successfulint32 +integer + +phase  +string + + +runSummary +object + +countint32 +integer + +errorint32 +integer + +failedint32 +integer +# + inconclusiveint32 +integer +! + +successfulint32 +integer +# + startedAt date-time +stringb +x-kubernetes-group-version-kind?=- group: argoproj.io + kind: AnalysisRun + version: v1alpha1 + + +$io.argoproj.v1alpha1.AnalysisRunList "(AnalysisRunList is a list of AnalysisRunitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"tList of analysisruns. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array2 +0 +.#/definitions/io.argoproj.v1alpha1.AnalysisRun + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsf +x-kubernetes-group-version-kindCA- group: argoproj.io + kind: AnalysisRunList + version: v1alpha1 + + +%io.argoproj.v1alpha1.AnalysisTemplatespec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specmetrics +object + +args +array +name +object + +name  +string + +value  +string + + valueFrom +object +@ +fieldRef4 fieldPath +object + + fieldPath  +string +T + secretKeyRefDkeyname +object) + +key  +string + +name  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string + +metrics +array +nameprovider +object +A +consecutiveErrorLimit(% +x-kubernetes-int-or-stringtrue + +1 +count(% +x-kubernetes-int-or-stringtrue + + +failureCondition  +string +8 + failureLimit(% +x-kubernetes-int-or-stringtrue + += +inconclusiveLimit(% +x-kubernetes-int-or-stringtrue + + + initialDelay  +string + +interval  +string + +name  +string + +provider +object + + +cloudWatchmetricDataQueries +object + +interval  +string + +metricDataQueries +array + +object + + +expression  +string + +id  +string + +label  +string + + +metricStat +object + +metric +object +V + +dimensionsH +array; +9 +object+ + +name  +string + +value  +string + + +metricName  +string + + namespace  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + +stat  +string + +unit  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + + +returnData  +boolean +P +datadogEquery +object/ + +interval  +string + +query  +string +H +graphite< +object. + +address  +string + +query  +string +H +influxdb< +object. + +profile  +string + +query  +string + +jobspec +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spectemplate +object +, +activeDeadlineSecondsint64 +integer +# + backoffLimitint32 +integer + +completionMode  +string +" + completionsint32 +integer + +manualSelector  +boolean +" + parallelismint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +suspend  +boolean + +template +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spec +containers +object +, +activeDeadlineSecondsint64 +integer + +affinity +object + + nodeAffinity +object + +/preferredDuringSchedulingIgnoredDuringExecution +array + +preferenceweight +object + + +preference +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecutionnodeSelectorTerms +object + +nodeSelectorTerms +array + +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + podAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +podAntiAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string +, +automountServiceAccountToken  +boolean +0 + +containers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + + dnsConfig +object +) + nameservers +array +  +string +S +optionsH +array; +9 +object+ + +name  +string + +value  +string +& +searches +array +  +string + + dnsPolicy  +string +" +enableServiceLinks  +boolean +1 +ephemeralContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +" +targetContainerName  +string +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string +h + hostAliasesY +arrayL +J +object< +' + hostnames +array +  +string + +ip  +string + +hostIPC  +boolean + + hostNetwork  +boolean + +hostPID  +boolean + +hostname  +string +F +imagePullSecrets2 +array% +# +object + +name  +string +0 +initContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + +nodeName  +string +P + nodeSelector@ +  +string +object" +x-kubernetes-map-type atomic + +0 +os*name +object + +name  +string + +overhead +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +preemptionPolicy  +string + +priorityint32 +integer + +priorityClassName  +string +] +readinessGatesK +array> +< conditionType +object + + conditionType  +string + + restartPolicy  +string + +runtimeClassName  +string + + schedulerName  +string + +securityContext +object + +fsGroupint64 +integer +" +fsGroupChangePolicy  +string +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string +8 +supplementalGroups" +array +int64 +integer +b +sysctlsW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + +serviceAccount  +string +! +serviceAccountName  +string +! +setHostnameAsFQDN  +boolean +% +shareProcessNamespace  +boolean + + subdomain  +string +4 +terminationGracePeriodSecondsint64 +integer + + tolerations +array + +object + +effect  +string + +key  +string + +operator  +string +( +tolerationSecondsint64 +integer + +value  +string + +topologySpreadConstraints +array +maxSkew topologyKeywhenUnsatisfiable +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +maxSkewint32 +integer +! + +minDomainsint32 +integer + + topologyKey  +string + +whenUnsatisfiable  +stringB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap + += +volumes2/ +$x-kubernetes-preserve-unknown-fieldstrue + +. +ttlSecondsAfterFinishedint32 +integer + +kayentaaddress applicationcanaryConfigNameconfigurationAccountNamemetricsAccountNamescopesstorageAccountName threshold +object + +address  +string + + application  +string + +canaryConfigName  +string +' +configurationAccountName  +string +! +metricsAccountName  +string + +scopes +array + controlScopeexperimentScopename +object + + controlScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +experimentScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +name  +string +! +storageAccountName  +string +k + threshold^marginalpass +object> + +marginalint64 +integer + +passint64 +integer +P +newRelicDquery +object. + +profile  +string + +query  +string +J + +prometheus< +object. + +address  +string + +query  +string +I + wavefront< +object. + +address  +string + +query  +string + +weburl +object + +body  +string +` +headersU +arrayH +Fkeyvalue +object* + +key  +string + +value  +string + +insecure  +boolean + +jsonPath  +string + +method  +string +% +timeoutSecondsint64 +integer + +url  +string + +successCondition  +stringg +x-kubernetes-group-version-kindDB- group: argoproj.io + kind: AnalysisTemplate + version: v1alpha1 + + +)io.argoproj.v1alpha1.AnalysisTemplateList "2AnalysisTemplateList is a list of AnalysisTemplateitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"yList of analysistemplates. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array7 +5 +3#/definitions/io.argoproj.v1alpha1.AnalysisTemplate + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsk +x-kubernetes-group-version-kindHF- group: argoproj.io + kind: AnalysisTemplateList + version: v1alpha1 + +7 +io.argoproj.v1alpha1.AppProject6"AppProject provides a logical grouping of applications, providing controls for: * where the apps may deploy to (cluster whitelist) * what may be deployed (repository whitelist, resource whitelist/blacklist) * who can access these applications (roles, OIDC group claims bindings) * and what they can do (RBAC policies) * automation access to these roles (JWT tokens)metadataspec +object2 + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +( +spec("4AppProjectSpec is the specification of an AppProject +object( + +clusterResourceBlacklist"MClusterResourceBlacklist contains list of blacklisted cluster level resources +array +"GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying concepts during lookup stages without having partially valid typesgroupkind +object+ + +group  +string + +kind  +string + +clusterResourceWhitelist"MClusterResourceWhitelist contains list of whitelisted cluster level resources +array +"GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying concepts during lookup stages without having partially valid typesgroupkind +object+ + +group  +string + +kind  +string +M + description>"1Description contains optional project description +string + + destinations"CDestinations contains list of destinations available for deployment +array +"LApplicationDestination holds information about the application's destination +object +c +name["NName is an alternate way of specifying the target cluster by its symbolic name +string + + namespace"Namespace specifies the target namespace for the application's resources. The namespace will only be set for namespace-scoped resources that have not set a value for .metadata.namespace +string +y +servero"bServer specifies the URL of the target cluster and must be set to the Kubernetes control plane API +string + +namespaceResourceBlacklist"QNamespaceResourceBlacklist contains list of blacklisted namespace level resources +array +"GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying concepts during lookup stages without having partially valid typesgroupkind +object+ + +group  +string + +kind  +string + +namespaceResourceWhitelist"QNamespaceResourceWhitelist contains list of whitelisted namespace level resources +array +"GroupKind specifies a Group and a Kind, but does not force a version. This is useful for identifying concepts during lookup stages without having partially valid typesgroupkind +object+ + +group  +string + +kind  +string + +orphanedResources"cOrphanedResources specifies if controller should monitor orphaned resources of apps in this project +object + +ignore"^Ignore contains a list of resources that are to be excluded from orphaned resources monitoring +array +"COrphanedResourceKey is a reference to a resource to be ignored from +object@ + +group  +string + +kind  +string + +name  +string +r +warnj"\Warn indicates if warning condition should be created for apps which have orphaned resources +boolean + +roles">Roles are user defined RBAC roles associated with this project +array +":ProjectRole represents a role that has access to a projectname +object +D + description5"(Description is a description of the role +string +_ +groupsU"9Groups are a list of OIDC group claims bound to this role +array +  +string + + jwtTokens"?JWTTokens are a list of generated JWT tokens bound to this role +array +";JWTToken holds the issuedAt and expiresAt values of a tokeniat +objectK + +expint64 +integer + +iatint64 +integer + +id  +string +1 +name)"Name is a name for this role +string + +policies"jPolicies Stores a list of casbin formatted strings that define access policies for the role in the project +array +  +string + + signatureKeys"tSignatureKeys contains a list of PGP key IDs that commits in Git must be signed with in order to be allowed for sync +array +"TSignatureKey is the specification of a key required to verify commit signatures withkeyID +objectA +? +keyID6")The ID of the key in hexadecimal notation +string + +sourceNamespacesv"ZSourceNamespaces defines the namespaces application resources are allowed to be created in +array +  +string +x + sourceReposi"MSourceRepos contains list of repository URLs which can be used for deployment +array +  +string + + syncWindows"CSyncWindows controls when syncs can be run for apps in this project +array +"kSyncWindow contains the kind, time, duration and attributes that are used to assign the syncWindows to apps +object +v + applicationsf"JApplications contains a list of applications that the window will apply to +array +  +string +j +clusters^"BClusters contains a list of clusters that the window will apply to +array +  +string +T +durationH";Duration is the amount of time the sync window will be open +string +F +kind>"1Kind defines if the window allows or blocks syncs +string +` + +manualSyncR"DManualSync enables manual syncs when they would otherwise be blocked +boolean +p + +namespacesb"FNamespaces contains a list of namespaces that the window will apply to +array +  +string +] +scheduleQ"DSchedule is the time the window will begin, specified in cron format +string +R +timeZoneF"9TimeZone of the sync that will be applied to the schedule +string + +status"?AppProjectStatus contains status information for AppProject CRs +object + +jwtTokensByRole"EJWTTokensByRole contains a list of JWT tokens issued for a given role +")JWTTokens represents a list of JWT tokens +object + +items +array +";JWTToken holds the issuedAt and expiresAt values of a tokeniat +objectK + +expint64 +integer + +iatint64 +integer + +id  +string +objecta +x-kubernetes-group-version-kind><- group: argoproj.io + kind: AppProject + version: v1alpha1 + + +#io.argoproj.v1alpha1.AppProjectList "&AppProjectList is a list of AppProjectitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"sList of appprojects. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array1 +/ +-#/definitions/io.argoproj.v1alpha1.AppProject + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindse +x-kubernetes-group-version-kindB@- group: argoproj.io + kind: AppProjectList + version: v1alpha1 + + + io.argoproj.v1alpha1.Application"4Application is a definition of Application resource.metadataspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +@ + operation@"EOperation contains information about a requested or running operation +object? + +info"8Info is a list of informational items for this operation +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + + initiatedBy"CInitiatedBy contains information about who initiated the operations +object +{ + automatedn"`Automated is set to true if operation was initiated automatically by the application controller. +boolean +S +usernameG":Username contains the name of a user who started operation +string + +retry"4Retry controls the strategy to apply if a sync fails +object + +backoff"EBackoff controls how to backoff on subsequent retries of failed syncs +object + +durationx"kDuration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h") +string +g +factor]int64"HFactor is a factor to multiply the base duration after each failed retry +integer +f + maxDurationW"JMaxDuration is the maximum amount of time allowed for the backoff strategy +string + +limitint64"nLimit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed. +integer +6 +sync6"*Sync contains parameters for the operation +object5 +t +dryRunj"\DryRun specifies to perform a `kubectl apply --dry-run` without actually performing the sync +boolean + + manifests|"`Manifests is an optional field that overrides sync source with a local directory for development +array +  +string +m +pruned"VPrune specifies to delete resources from the cluster that are no longer tracked in git +boolean + + resources"=Resources describes which resources shall be part of the sync +array +"1SyncOperationResource contains resources to sync.kindname +objectZ + +group  +string + +kind  +string + +name  +string + + namespace  +string + +revision"Revision is the revision (Git) or chart version (Helm) which to sync the application to If omitted, will use the revision specified in app spec. +string +) +source("Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operationrepoURL +object' +r +charti"\Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo. +string + + directory"/Directory holds path/directory specific options +object + +exclude"Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation +string + +include"tInclude contains a glob pattern to match paths against that should be explicitly included during manifest generation +string + +jsonnet")Jsonnet holds options specific to Jsonnet +object + +extVars"/ExtVars is a list of Jsonnet External Variables +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +B +libs:"Additional library search dirs +array +  +string + +tlas"-TLAS is a list of Jsonnet Top-level Arguments +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +` +recurseU"GRecurse specifies whether to scan a directory recursively for manifests +boolean + +helm " Helm holds helm specific options +object + +fileParameters"7FileParameters are file parameters to the helm template +array +"_HelmFileParameter is a file parameter that's passed to helm template during manifest generation +object +; +name3"&Name is the name of the Helm parameter +string +^ +pathV"IPath is the path to the file containing the values for the Helm parameter +string + +ignoreMissingValueFiles"IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values +boolean + + +parameters"nParameters is a list of Helm parameters which are passed to the helm template command upon manifest generation +array +"VHelmParameter is a parameter that's passed to helm template during manifest generation +object +u + forceStringf"XForceString determines whether to tell Helm to interpret booleans and numbers as strings +boolean +; +name3"&Name is the name of the Helm parameter +string +? +value6")Value is the value for the Helm parameter +string +l +passCredentialsY"KPassCredentials pass credentials to all domains (Helm's --pass-credentials) +boolean +t + releaseNamee"XReleaseName is the Helm release name to use. If omitted it will use the application name +string +j +skipCrds^"PSkipCrds skips custom resource definition installation step (Helm's --skip-crds) +boolean +u + +valueFilesg"KValuesFiles is a list of Helm value files to use when generating a template +array +  +string +o +valuese"XValues specifies Helm values to be passed to helm template, typically defined as a block +string +O +versionD"7Version is the Helm version to use for templating ("3") +string + + kustomize"*Kustomize holds kustomize specific options +object + +commonAnnotationso"RCommonAnnotations is a list of additional annotations to add to rendered manifests +  +string +object +u + commonLabelse"HCommonLabels is a list of additional labels to add to rendered manifests +  +string +object + +forceCommonAnnotations{"mForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps +boolean + +forceCommonLabelsq"cForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps +boolean + +images";Images is a list of Kustomize image override specifications +array} +{"nKustomizeImage represents a Kustomize image definition in the format [old_image_name=]: +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string +i + syncOptionsZ">SyncOptions provide per-sync sync-options, e.g. Validate=false +array +  +string + + syncStrategy".SyncStrategy describes how to perform the sync +object + +apply"9Apply will perform a `kubectl apply` to perform the sync. +object + +force"Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times. +boolean + +hook"[Hook will submit any referenced resources to perform the sync. This is the default strategy +object + +force"Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times. +boolean +E +specE"ApplicationSpec represents desired application state. Contains link to repository with application definition and additional parameters link definition revision. destinationprojectsource +objectC + + destination"HDestination is a reference to the target Kubernetes server and namespace +object +c +name["NName is an alternate way of specifying the target cluster by its symbolic name +string + + namespace"Namespace specifies the target namespace for the application's resources. The namespace will only be set for namespace-scoped resources that have not set a value for .metadata.namespace +string +y +servero"bServer specifies the URL of the target cluster and must be set to the Kubernetes control plane API +string + +ignoreDifferences"cIgnoreDifferences is a list of resources and their fields which should be ignored during comparison +array +"ResourceIgnoreDifferences contains resource filter and list of json paths which should be ignored during comparison with live state.kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string + +managedFieldsManagers"ManagedFieldsManagers is a list of trusted managers. Fields mutated by those managers will take precedence over the desired state defined in the SCM and won't be displayed in diffs +array +  +string + +name  +string + + namespace  +string + +info"kInfo contains a list of information (URLs, email addresses, and plain text) that relates to the application +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project"Project is a reference to the project this application belongs to. The empty string means that application belongs to the 'default' project. +string + +revisionHistoryLimitint64"RevisionHistoryLimit limits the number of items kept in the application's revision history, which is used for informational purposes as well as for rollbacks to previous versions. This should only be changed in exceptional circumstances. Setting to zero will store no history. This will reduce storage used. Increasing will increase the space used to store the history, so we do not recommend increasing it. Default is 10. +integer +( +source("MSource is a reference to the location of the application's manifests or chartrepoURL +object' +r +charti"\Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo. +string + + directory"/Directory holds path/directory specific options +object + +exclude"Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation +string + +include"tInclude contains a glob pattern to match paths against that should be explicitly included during manifest generation +string + +jsonnet")Jsonnet holds options specific to Jsonnet +object + +extVars"/ExtVars is a list of Jsonnet External Variables +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +B +libs:"Additional library search dirs +array +  +string + +tlas"-TLAS is a list of Jsonnet Top-level Arguments +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +` +recurseU"GRecurse specifies whether to scan a directory recursively for manifests +boolean + +helm " Helm holds helm specific options +object + +fileParameters"7FileParameters are file parameters to the helm template +array +"_HelmFileParameter is a file parameter that's passed to helm template during manifest generation +object +; +name3"&Name is the name of the Helm parameter +string +^ +pathV"IPath is the path to the file containing the values for the Helm parameter +string + +ignoreMissingValueFiles"IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values +boolean + + +parameters"nParameters is a list of Helm parameters which are passed to the helm template command upon manifest generation +array +"VHelmParameter is a parameter that's passed to helm template during manifest generation +object +u + forceStringf"XForceString determines whether to tell Helm to interpret booleans and numbers as strings +boolean +; +name3"&Name is the name of the Helm parameter +string +? +value6")Value is the value for the Helm parameter +string +l +passCredentialsY"KPassCredentials pass credentials to all domains (Helm's --pass-credentials) +boolean +t + releaseNamee"XReleaseName is the Helm release name to use. If omitted it will use the application name +string +j +skipCrds^"PSkipCrds skips custom resource definition installation step (Helm's --skip-crds) +boolean +u + +valueFilesg"KValuesFiles is a list of Helm value files to use when generating a template +array +  +string +o +valuese"XValues specifies Helm values to be passed to helm template, typically defined as a block +string +O +versionD"7Version is the Helm version to use for templating ("3") +string + + kustomize"*Kustomize holds kustomize specific options +object + +commonAnnotationso"RCommonAnnotations is a list of additional annotations to add to rendered manifests +  +string +object +u + commonLabelse"HCommonLabels is a list of additional labels to add to rendered manifests +  +string +object + +forceCommonAnnotations{"mForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps +boolean + +forceCommonLabelsq"cForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps +boolean + +images";Images is a list of Kustomize image override specifications +array} +{"nKustomizeImage represents a Kustomize image definition in the format [old_image_name=]: +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string + + + +syncPolicy +"9SyncPolicy controls when and how a sync will be performed +object + + automated"@Automated will keep an application synced to the target revision +object +\ + +allowEmptyN"@AllowEmpty allows apps have zero live resources (default: false) +boolean + +prune"Prune specifies whether to delete resources from the cluster that are not found in the sources anymore as part of automated sync (default: false) +boolean + +selfHeal"{SelfHeal specifes whether to revert resources back to their desired state upon modification in the cluster (default: false) +boolean + +retry")Retry controls failed sync retry behavior +object + +backoff"EBackoff controls how to backoff on subsequent retries of failed syncs +object + +durationx"kDuration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h") +string +g +factor]int64"HFactor is a factor to multiply the base duration after each failed retry +integer +f + maxDurationW"JMaxDuration is the maximum amount of time allowed for the backoff strategy +string + +limitint64"nLimit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed. +integer +^ + syncOptionsO"3Options allow you to specify whole app sync-options +array +  +string + +status"AApplicationStatus contains status information for the application +object + + +conditions"AConditions is a list of currently observed application conditions +array +"iApplicationCondition contains details about an application condition, which is usally an error or warningmessagetype +object +l +lastTransitionTimeV date-time">LastTransitionTime is the time the condition was last observed +string +b +messageW"JMessage contains human-readable message indicating details about condition +string +: +type2"%Type is an application condition type +string + +health"IHealth contains information about the application's current health status +object +f +message["NMessage is a human-readable informational message describing the health status +string +R +statusH";Status holds the status code of the application or resource +string +- +history,"AHistory contains information about the application's sync history +array, +,"BRevisionHistory contains history information about a previous sync +deployedAtidrevision +object+ +d +deployStartedAtQ date-time"9DeployStartedAt holds the time the sync operation started +string +\ + +deployedAtN date-time"6DeployedAt holds the time the sync operation completed +string +W +idQint64": +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string + + +observedAt date-time"ObservedAt indicates when the application state was updated without querying latest git state Deprecated: controller no longer updates ObservedAt field +string +x +operationStatex"POperationState contains information about any ongoing operations, such as a sync operationphase startedAt +objectw +V + +finishedAtH date-time"0FinishedAt contains time of operation completion +string +u +messagej"]Message holds any pertinent messages when attempting to perform operation (typically errors). +string +? + operation?"-Operation is the original requested operation +object? + +info"8Info is a list of informational items for this operation +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + + initiatedBy"CInitiatedBy contains information about who initiated the operations +object +{ + automatedn"`Automated is set to true if operation was initiated automatically by the application controller. +boolean +S +usernameG":Username contains the name of a user who started operation +string + +retry"4Retry controls the strategy to apply if a sync fails +object + +backoff"EBackoff controls how to backoff on subsequent retries of failed syncs +object + +durationx"kDuration is the amount to back off. Default unit is seconds, but could also be a duration (e.g. "2m", "1h") +string +g +factor]int64"HFactor is a factor to multiply the base duration after each failed retry +integer +f + maxDurationW"JMaxDuration is the maximum amount of time allowed for the backoff strategy +string + +limitint64"nLimit is the maximum number of attempts for retrying a failed sync. If set to 0, no retries will be performed. +integer +6 +sync6"*Sync contains parameters for the operation +object5 +t +dryRunj"\DryRun specifies to perform a `kubectl apply --dry-run` without actually performing the sync +boolean + + manifests|"`Manifests is an optional field that overrides sync source with a local directory for development +array +  +string +m +pruned"VPrune specifies to delete resources from the cluster that are no longer tracked in git +boolean + + resources"=Resources describes which resources shall be part of the sync +array +"1SyncOperationResource contains resources to sync.kindname +objectZ + +group  +string + +kind  +string + +name  +string + + namespace  +string + +revision"Revision is the revision (Git) or chart version (Helm) which to sync the application to If omitted, will use the revision specified in app spec. +string +) +source("Source overrides the source definition set in the application. This is typically set in a Rollback operation and is nil during a Sync operationrepoURL +object' +r +charti"\Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo. +string + + directory"/Directory holds path/directory specific options +object + +exclude"Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation +string + +include"tInclude contains a glob pattern to match paths against that should be explicitly included during manifest generation +string + +jsonnet")Jsonnet holds options specific to Jsonnet +object + +extVars"/ExtVars is a list of Jsonnet External Variables +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +B +libs:"Additional library search dirs +array +  +string + +tlas"-TLAS is a list of Jsonnet Top-level Arguments +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +` +recurseU"GRecurse specifies whether to scan a directory recursively for manifests +boolean + +helm " Helm holds helm specific options +object + +fileParameters"7FileParameters are file parameters to the helm template +array +"_HelmFileParameter is a file parameter that's passed to helm template during manifest generation +object +; +name3"&Name is the name of the Helm parameter +string +^ +pathV"IPath is the path to the file containing the values for the Helm parameter +string + +ignoreMissingValueFiles"IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values +boolean + + +parameters"nParameters is a list of Helm parameters which are passed to the helm template command upon manifest generation +array +"VHelmParameter is a parameter that's passed to helm template during manifest generation +object +u + forceStringf"XForceString determines whether to tell Helm to interpret booleans and numbers as strings +boolean +; +name3"&Name is the name of the Helm parameter +string +? +value6")Value is the value for the Helm parameter +string +l +passCredentialsY"KPassCredentials pass credentials to all domains (Helm's --pass-credentials) +boolean +t + releaseNamee"XReleaseName is the Helm release name to use. If omitted it will use the application name +string +j +skipCrds^"PSkipCrds skips custom resource definition installation step (Helm's --skip-crds) +boolean +u + +valueFilesg"KValuesFiles is a list of Helm value files to use when generating a template +array +  +string +o +valuese"XValues specifies Helm values to be passed to helm template, typically defined as a block +string +O +versionD"7Version is the Helm version to use for templating ("3") +string + + kustomize"*Kustomize holds kustomize specific options +object + +commonAnnotationso"RCommonAnnotations is a list of additional annotations to add to rendered manifests +  +string +object +u + commonLabelse"HCommonLabels is a list of additional labels to add to rendered manifests +  +string +object + +forceCommonAnnotations{"mForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps +boolean + +forceCommonLabelsq"cForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps +boolean + +images";Images is a list of Kustomize image override specifications +array} +{"nKustomizeImage represents a Kustomize image definition in the format [old_image_name=]: +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string +i + syncOptionsZ">SyncOptions provide per-sync sync-options, e.g. Validate=false +array +  +string + + syncStrategy".SyncStrategy describes how to perform the sync +object + +apply"9Apply will perform a `kubectl apply` to perform the sync. +object + +force"Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times. +boolean + +hook"[Hook will submit any referenced resources to perform the sync. This is the default strategy +object + +force"Force indicates whether or not to supply the --force flag to `kubectl apply`. The --force flag deletes and re-create the resource, when PATCH encounters conflict and has retried for 5 times. +boolean +A +phase8"+Phase is the current phase of the operation +string +P + +retryCountBint64"-RetryCount contains time of operation retries +integer +O + startedAtB date-time"*StartedAt contains time of operation start +string +3 + +syncResult3",SyncResult is the result of a Sync operationrevision +object3 + + resources "_Resources contains a list of sync result items for each individual resource in a sync operation +array +"HResourceResult holds the operation result details of a specific resourcegroupkindname namespaceversion +object +C +group:"-Group specifies the API group of the resource +string + + hookPhase"HookPhase contains the state of any operation associated with this resource OR hook This can also contain values for non-hook resources. +string +^ +hookTypeR"EHookType specifies the type of the hook. Empty for non-hook resources +string +@ +kind8"+Kind specifies the API kind of the resource +string +i +message^"QMessage contains an informational or error message for the last sync OR operation +string +< +name4"'Name specifies the name of the resource +string +R + namespaceE"8Namespace specifies the target namespace of the resource +string + +status"Status holds the final result of the sync. Will be empty if the resources is yet to be applied/pruned and is always zero-value for hooks +string +o + syncPhaseb"USyncPhase indicates the particular phase of the sync that this result was acquired in +string +I +version>"1Version specifies the API version of the resource +string +Y +revisionM"@Revision holds the revision this sync operation was performed to +string +( +source("[Source records the application source information of the sync, used for comparing auto-syncrepoURL +object' +r +charti"\Chart is a Helm chart name, and must be specified for applications sourced from a Helm repo. +string + + directory"/Directory holds path/directory specific options +object + +exclude"Exclude contains a glob pattern to match paths against that should be explicitly excluded from being used during manifest generation +string + +include"tInclude contains a glob pattern to match paths against that should be explicitly included during manifest generation +string + +jsonnet")Jsonnet holds options specific to Jsonnet +object + +extVars"/ExtVars is a list of Jsonnet External Variables +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +B +libs:"Additional library search dirs +array +  +string + +tlas"-TLAS is a list of Jsonnet Top-level Arguments +array +"SJsonnetVar represents a variable to be passed to jsonnet during manifest generationnamevalue +objectA + +code  +boolean + +name  +string + +value  +string +` +recurseU"GRecurse specifies whether to scan a directory recursively for manifests +boolean + +helm " Helm holds helm specific options +object + +fileParameters"7FileParameters are file parameters to the helm template +array +"_HelmFileParameter is a file parameter that's passed to helm template during manifest generation +object +; +name3"&Name is the name of the Helm parameter +string +^ +pathV"IPath is the path to the file containing the values for the Helm parameter +string + +ignoreMissingValueFiles"IgnoreMissingValueFiles prevents helm template from failing when valueFiles do not exist locally by not appending them to helm template --values +boolean + + +parameters"nParameters is a list of Helm parameters which are passed to the helm template command upon manifest generation +array +"VHelmParameter is a parameter that's passed to helm template during manifest generation +object +u + forceStringf"XForceString determines whether to tell Helm to interpret booleans and numbers as strings +boolean +; +name3"&Name is the name of the Helm parameter +string +? +value6")Value is the value for the Helm parameter +string +l +passCredentialsY"KPassCredentials pass credentials to all domains (Helm's --pass-credentials) +boolean +t + releaseNamee"XReleaseName is the Helm release name to use. If omitted it will use the application name +string +j +skipCrds^"PSkipCrds skips custom resource definition installation step (Helm's --skip-crds) +boolean +u + +valueFilesg"KValuesFiles is a list of Helm value files to use when generating a template +array +  +string +o +valuese"XValues specifies Helm values to be passed to helm template, typically defined as a block +string +O +versionD"7Version is the Helm version to use for templating ("3") +string + + kustomize"*Kustomize holds kustomize specific options +object + +commonAnnotationso"RCommonAnnotations is a list of additional annotations to add to rendered manifests +  +string +object +u + commonLabelse"HCommonLabels is a list of additional labels to add to rendered manifests +  +string +object + +forceCommonAnnotations{"mForceCommonAnnotations specifies whether to force applying common annotations to resources for Kustomize apps +boolean + +forceCommonLabelsq"cForceCommonLabels specifies whether to force applying common labels to resources for Kustomize apps +boolean + +images";Images is a list of Kustomize image override specifications +array} +{"nKustomizeImage represents a Kustomize image definition in the format [old_image_name=]: +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string + + reconciledAtu date-time"]ReconciledAt indicates when the application state was reconciled using the latest git version +string + +resourceHealthSourcet"gResourceHealthSource indicates where the resource health status is stored: inline if not set or appTree +string + + resources"GResources is a list of Kubernetes resources managed by this application +array +"iResourceStatus holds the current sync and health status of a resource TODO: describe members of this type +object + +group  +string + +health"iHealthStatus contains information about the currently observed health state of an application or resource +object +f +message["NMessage is a human-readable informational message describing the health status +string +R +statusH";Status holds the status code of the application or resource +string + +hook  +boolean + +kind  +string + +name  +string + + namespace  +string + +requiresPruning  +boolean +\ +statusR"ESyncStatusCode is a type which represents possible comparison results +string + +version  +string +L + +sourceType>"1SourceType specifies the type of this application +string + +summary"MSummary contains a list of URLs and container images used by this application +object +p + externalURLs`"DExternalURLs holds all external URLs of application child resources. +array +  +string +] +imagesS"7Images holds all images of application child resources. +array +  +string +/ +sync/"ESync contains information about the application's current sync statusstatus +object/ +- + +comparedTo-": +string +Z + +namePrefixL"?NamePrefix is a prefix appended to resources for Kustomize apps +string +Z + +nameSuffixL"?NameSuffix is a suffix appended to resources for Kustomize apps +string +b +versionW"JVersion controls which version of Kustomize to use for rendering manifests +string +} +pathu"hPath is a directory path within the Git repository, and is only valid for applications sourced from Git. +string + +plugin"FConfigManagementPlugin holds config management plugin specific options +object + +env"-Env is a list of environment variable entries +array +"=EnvEntry represents an entry in the application's environmentnamevalue +object +U +nameM"@Name is the name of the variable, usually expressed in uppercase +string +8 +value/""Value is the value of the variable +string + +name  +string +r +repoURLg"ZRepoURL is the URL to the repository (Git or Helm) that contains the application manifests +string + +targetRevision"TargetRevision defines the revision of the source to sync the application to. In case of Git, this can be commit, tag, or branch. If omitted, will equal to HEAD. In case of Helm, this is a semver tag for the Chart's version. +string +n +revisionb"URevision contains information about the revision the comparison has been performed to +string +A +status7"*Status is the sync state of the comparison +stringb +x-kubernetes-group-version-kind?=- group: argoproj.io + kind: Application + version: v1alpha1 + + +$io.argoproj.v1alpha1.ApplicationList "(ApplicationList is a list of Applicationitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"tList of applications. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array2 +0 +.#/definitions/io.argoproj.v1alpha1.Application + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsf +x-kubernetes-group-version-kindCA- group: argoproj.io + kind: ApplicationList + version: v1alpha1 + + +#io.argoproj.v1alpha1.ApplicationSetDZmetadataspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specߧ +generatorstemplate +object +Ƒ + +generators +array + +object + +clusterDecisionResource configMapRef +object + + configMapRef  +string + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +name  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +clusters +object + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +gitrepoURLrevision +object +a + directoriesR +arrayE +Cpath +object. + +exclude  +boolean + +path  +string +B +files9 +array, +*path +object + +path  +string + +repoURL  +string +* +requeueAfterSecondsint64 +integer + +revision  +string + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +listelements +object +M +elementsA +array4 +2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +matrixܷ +generators +object + + +generators +array + +object + +clusterDecisionResource configMapRef +object + + configMapRef  +string + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +name  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +clusters +object + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +gitrepoURLrevision +object +a + directoriesR +arrayE +Cpath +object. + +exclude  +boolean + +path  +string +B +files9 +array, +*path +object + +path  +string + +repoURL  +string +* +requeueAfterSecondsint64 +integer + +revision  +string + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +listelements +object +M +elementsA +array4 +2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +< +matrix2/ +$x-kubernetes-preserve-unknown-fieldstrue + +; +merge2/ +$x-kubernetes-preserve-unknown-fieldstrue + + + pullRequest +object + +bitbucketServerapiprojectrepo +object + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + +repo  +string +D +filters9 +array, +* +object + + branchMatch  +string + +giteaapiownerrepo +object + +api  +string + +insecure  +boolean + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +githubownerrepo +object + +api  +string + + appSecretName  +string +$ +labels +array +  +string + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabproject +object + +api  +string +$ +labels +array +  +string + +project  +string + +pullRequestState  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +# + scmProvider# +object# + + azureDevOpsaccessTokenRef organization teamProject +object +b +accessTokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + + allBranches  +boolean + +api  +string + + organization  +string + + teamProject  +string + + bitbucketappPasswordRefowneruser +object + + allBranches  +boolean +b +appPasswordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +owner  +string + +user  +string + +bitbucketServerapiproject +object + + allBranches  +boolean + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + + cloneProtocol  +string + +filters +array + +object + + branchMatch  +string + + +labelMatch  +string +- +pathsDoNotExist +array +  +string +( + +pathsExist +array +  +string + +repositoryMatch  +string + +giteaapiowner +object + + allBranches  +boolean + +api  +string + +insecure  +boolean + +owner  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +github organization +object + + allBranches  +boolean + +api  +string + + appSecretName  +string + + organization  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabgroup +object + + allBranches  +boolean + +api  +string + +group  +string + +includeSubgroups  +boolean +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +merge +generators mergeKeys +object + + +generators +array + +object + +clusterDecisionResource configMapRef +object + + configMapRef  +string + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +name  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +clusters +object + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +% +values +  +string +object + +gitrepoURLrevision +object +a + directoriesR +arrayE +Cpath +object. + +exclude  +boolean + +path  +string +B +files9 +array, +*path +object + +path  +string + +repoURL  +string +* +requeueAfterSecondsint64 +integer + +revision  +string + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +listelements +object +M +elementsA +array4 +2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +< +matrix2/ +$x-kubernetes-preserve-unknown-fieldstrue + +; +merge2/ +$x-kubernetes-preserve-unknown-fieldstrue + + + pullRequest +object + +bitbucketServerapiprojectrepo +object + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + +repo  +string +D +filters9 +array, +* +object + + branchMatch  +string + +giteaapiownerrepo +object + +api  +string + +insecure  +boolean + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +githubownerrepo +object + +api  +string + + appSecretName  +string +$ +labels +array +  +string + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabproject +object + +api  +string +$ +labels +array +  +string + +project  +string + +pullRequestState  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +# + scmProvider# +object# + + azureDevOpsaccessTokenRef organization teamProject +object +b +accessTokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + + allBranches  +boolean + +api  +string + + organization  +string + + teamProject  +string + + bitbucketappPasswordRefowneruser +object + + allBranches  +boolean +b +appPasswordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +owner  +string + +user  +string + +bitbucketServerapiproject +object + + allBranches  +boolean + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + + cloneProtocol  +string + +filters +array + +object + + branchMatch  +string + + +labelMatch  +string +- +pathsDoNotExist +array +  +string +( + +pathsExist +array +  +string + +repositoryMatch  +string + +giteaapiowner +object + + allBranches  +boolean + +api  +string + +insecure  +boolean + +owner  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +github organization +object + + allBranches  +boolean + +api  +string + + appSecretName  +string + + organization  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabgroup +object + + allBranches  +boolean + +api  +string + +group  +string + +includeSubgroups  +boolean +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +' + mergeKeys +array +  +string + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + + pullRequest +object + +bitbucketServerapiprojectrepo +object + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + +repo  +string +D +filters9 +array, +* +object + + branchMatch  +string + +giteaapiownerrepo +object + +api  +string + +insecure  +boolean + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +githubownerrepo +object + +api  +string + + appSecretName  +string +$ +labels +array +  +string + +owner  +string + +repo  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabproject +object + +api  +string +$ +labels +array +  +string + +project  +string + +pullRequestState  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string +# + scmProvider# +object# + + azureDevOpsaccessTokenRef organization teamProject +object +b +accessTokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + + allBranches  +boolean + +api  +string + + organization  +string + + teamProject  +string + + bitbucketappPasswordRefowneruser +object + + allBranches  +boolean +b +appPasswordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +owner  +string + +user  +string + +bitbucketServerapiproject +object + + allBranches  +boolean + +api  +string + + basicAuth passwordRefusername +objectz +_ + passwordRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +username  +string + +project  +string + + cloneProtocol  +string + +filters +array + +object + + branchMatch  +string + + +labelMatch  +string +- +pathsDoNotExist +array +  +string +( + +pathsExist +array +  +string + +repositoryMatch  +string + +giteaapiowner +object + + allBranches  +boolean + +api  +string + +insecure  +boolean + +owner  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +github organization +object + + allBranches  +boolean + +api  +string + + appSecretName  +string + + organization  +string +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string + +gitlabgroup +object + + allBranches  +boolean + +api  +string + +group  +string + +includeSubgroups  +boolean +\ +tokenRefPkey +secretName +object/ + +key  +string + + +secretName  +string +* +requeueAfterSecondsint64 +integer + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + + +goTemplate  +boolean +I + +syncPolicy; +object- ++ +preserveResourcesOnDeletion  +boolean + +templatemetadataspec +object + +metadata +object +* + annotations +  +string +object +( + +finalizers +array +  +string +% +labels +  +string +object + +name  +string + + namespace  +string + +spec destinationprojectsource +object +c + destinationT +objectF + +name  +string + + namespace  +string + +server  +string + +ignoreDifferences +array +kind +object + +group  +string +/ +jqPathExpressions +array +  +string +* + jsonPointers +array +  +string + +kind  +string +3 +managedFieldsManagers +array +  +string + +name  +string + + namespace  +string +_ +infoW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +project  +string ++ +revisionHistoryLimitint64 +integer + +source repoURL +object + +chart  +string + + directory +object + +exclude  +string + +include  +string + +jsonnet +object +x +extVarsm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string +" +libs +array +  +string +u +tlasm +array` +^namevalue +objectA + +code  +boolean + +name  +string + +value  +string + +recurse  +boolean + +helm +object +Y +fileParametersG +array: +8 +object* + +name  +string + +path  +string +' +ignoreMissingValueFiles  +boolean +s + +parameterse +arrayX +V +objectH + + forceString  +boolean + +name  +string + +value  +string + +passCredentials  +boolean + + releaseName  +string + +skipCrds  +boolean +( + +valueFiles +array +  +string + +values  +string + +version  +string + + kustomize +object +0 +commonAnnotations +  +string +object ++ + commonLabels +  +string +object +& +forceCommonAnnotations  +boolean +! +forceCommonLabels  +boolean +$ +images +array +  +string + + +namePrefix  +string + + +nameSuffix  +string + +version  +string + +path  +string + +plugin +objectu +^ +envW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +name  +string + +repoURL  +string + +targetRevision  +string + + +syncPolicy +object +h + automated[ +objectM + + +allowEmpty  +boolean + +prune  +boolean + +selfHeal  +boolean + +retry +object +m +backoffb +objectT + +duration  +string + +factorint64 +integer + + maxDuration  +string + +limitint64 +integer +) + syncOptions +array +  +string + +status +object + + +conditions +array +messagereasonstatustype +object +, +lastTransitionTime date-time +string + +message  +string + +reason  +string + +status  +string + +type  +stringe +x-kubernetes-group-version-kindB@- group: argoproj.io + kind: ApplicationSet + version: v1alpha1 + + +'io.argoproj.v1alpha1.ApplicationSetList ".ApplicationSetList is a list of ApplicationSetitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"wList of applicationsets. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array5 +3 +1#/definitions/io.argoproj.v1alpha1.ApplicationSet + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsi +x-kubernetes-group-version-kindFD- group: argoproj.io + kind: ApplicationSetList + version: v1alpha1 + + +,io.argoproj.v1alpha1.ClusterAnalysisTemplatespec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specmetrics +object + +args +array +name +object + +name  +string + +value  +string + + valueFrom +object +@ +fieldRef4 fieldPath +object + + fieldPath  +string +T + secretKeyRefDkeyname +object) + +key  +string + +name  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string + +metrics +array +nameprovider +object +A +consecutiveErrorLimit(% +x-kubernetes-int-or-stringtrue + +1 +count(% +x-kubernetes-int-or-stringtrue + + +failureCondition  +string +8 + failureLimit(% +x-kubernetes-int-or-stringtrue + += +inconclusiveLimit(% +x-kubernetes-int-or-stringtrue + + + initialDelay  +string + +interval  +string + +name  +string + +provider +object + + +cloudWatchmetricDataQueries +object + +interval  +string + +metricDataQueries +array + +object + + +expression  +string + +id  +string + +label  +string + + +metricStat +object + +metric +object +V + +dimensionsH +array; +9 +object+ + +name  +string + +value  +string + + +metricName  +string + + namespace  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + +stat  +string + +unit  +string +2 +period(% +x-kubernetes-int-or-stringtrue + + + +returnData  +boolean +P +datadogEquery +object/ + +interval  +string + +query  +string +H +graphite< +object. + +address  +string + +query  +string +H +influxdb< +object. + +profile  +string + +query  +string + +jobspec +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spectemplate +object +, +activeDeadlineSecondsint64 +integer +# + backoffLimitint32 +integer + +completionMode  +string +" + completionsint32 +integer + +manualSelector  +boolean +" + parallelismint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +suspend  +boolean + +template +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spec +containers +object +, +activeDeadlineSecondsint64 +integer + +affinity +object + + nodeAffinity +object + +/preferredDuringSchedulingIgnoredDuringExecution +array + +preferenceweight +object + + +preference +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecutionnodeSelectorTerms +object + +nodeSelectorTerms +array + +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + podAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +podAntiAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string +, +automountServiceAccountToken  +boolean +0 + +containers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + + dnsConfig +object +) + nameservers +array +  +string +S +optionsH +array; +9 +object+ + +name  +string + +value  +string +& +searches +array +  +string + + dnsPolicy  +string +" +enableServiceLinks  +boolean +1 +ephemeralContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +" +targetContainerName  +string +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string +h + hostAliasesY +arrayL +J +object< +' + hostnames +array +  +string + +ip  +string + +hostIPC  +boolean + + hostNetwork  +boolean + +hostPID  +boolean + +hostname  +string +F +imagePullSecrets2 +array% +# +object + +name  +string +0 +initContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + +nodeName  +string +P + nodeSelector@ +  +string +object" +x-kubernetes-map-type atomic + +0 +os*name +object + +name  +string + +overhead +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +preemptionPolicy  +string + +priorityint32 +integer + +priorityClassName  +string +] +readinessGatesK +array> +< conditionType +object + + conditionType  +string + + restartPolicy  +string + +runtimeClassName  +string + + schedulerName  +string + +securityContext +object + +fsGroupint64 +integer +" +fsGroupChangePolicy  +string +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string +8 +supplementalGroups" +array +int64 +integer +b +sysctlsW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + +serviceAccount  +string +! +serviceAccountName  +string +! +setHostnameAsFQDN  +boolean +% +shareProcessNamespace  +boolean + + subdomain  +string +4 +terminationGracePeriodSecondsint64 +integer + + tolerations +array + +object + +effect  +string + +key  +string + +operator  +string +( +tolerationSecondsint64 +integer + +value  +string + +topologySpreadConstraints +array +maxSkew topologyKeywhenUnsatisfiable +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +maxSkewint32 +integer +! + +minDomainsint32 +integer + + topologyKey  +string + +whenUnsatisfiable  +stringB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap + += +volumes2/ +$x-kubernetes-preserve-unknown-fieldstrue + +. +ttlSecondsAfterFinishedint32 +integer + +kayentaaddress applicationcanaryConfigNameconfigurationAccountNamemetricsAccountNamescopesstorageAccountName threshold +object + +address  +string + + application  +string + +canaryConfigName  +string +' +configurationAccountName  +string +! +metricsAccountName  +string + +scopes +array + controlScopeexperimentScopename +object + + controlScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +experimentScopeendregionscopestartstep +objectt + +end  +string + +region  +string + +scope  +string + +start  +string + +stepint64 +integer + +name  +string +! +storageAccountName  +string +k + threshold^marginalpass +object> + +marginalint64 +integer + +passint64 +integer +P +newRelicDquery +object. + +profile  +string + +query  +string +J + +prometheus< +object. + +address  +string + +query  +string +I + wavefront< +object. + +address  +string + +query  +string + +weburl +object + +body  +string +` +headersU +arrayH +Fkeyvalue +object* + +key  +string + +value  +string + +insecure  +boolean + +jsonPath  +string + +method  +string +% +timeoutSecondsint64 +integer + +url  +string + +successCondition  +stringn +x-kubernetes-group-version-kindKI- group: argoproj.io + kind: ClusterAnalysisTemplate + version: v1alpha1 + + + +0io.argoproj.v1alpha1.ClusterAnalysisTemplateList "@ClusterAnalysisTemplateList is a list of ClusterAnalysisTemplateitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"List of clusteranalysistemplates. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array> +< +:#/definitions/io.argoproj.v1alpha1.ClusterAnalysisTemplate + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsr +x-kubernetes-group-version-kindOM- group: argoproj.io + kind: ClusterAnalysisTemplateList + version: v1alpha1 + + +io.argoproj.v1alpha1.Experimentspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec templates +object + +analyses +array +name templateName +object + +args +array +name +object + +name  +string + +value  +string + + valueFrom +object +@ +fieldRef4 fieldPath +object + + fieldPath  +string +T + secretKeyRefDkeyname +object) + +key  +string + +name  +string + + clusterScope  +boolean + +name  +string +% +requiredForCompletion  +boolean + + templateName  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +duration  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string +. +progressDeadlineSecondsint32 +integer +, +scaleDownDelaySecondsint32 +integer + + templates +array +nameselectortemplate +object +& +minReadySecondsint32 +integer + +name  +string + +replicasint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +service  +object + +template +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spec +containers +object +, +activeDeadlineSecondsint64 +integer + +affinity +object + + nodeAffinity +object + +/preferredDuringSchedulingIgnoredDuringExecution +array + +preferenceweight +object + + +preference +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecutionnodeSelectorTerms +object + +nodeSelectorTerms +array + +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + podAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +podAntiAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string +, +automountServiceAccountToken  +boolean +0 + +containers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + + dnsConfig +object +) + nameservers +array +  +string +S +optionsH +array; +9 +object+ + +name  +string + +value  +string +& +searches +array +  +string + + dnsPolicy  +string +" +enableServiceLinks  +boolean +1 +ephemeralContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +" +targetContainerName  +string +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string +h + hostAliasesY +arrayL +J +object< +' + hostnames +array +  +string + +ip  +string + +hostIPC  +boolean + + hostNetwork  +boolean + +hostPID  +boolean + +hostname  +string +F +imagePullSecrets2 +array% +# +object + +name  +string +0 +initContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + +nodeName  +string +P + nodeSelector@ +  +string +object" +x-kubernetes-map-type atomic + +0 +os*name +object + +name  +string + +overhead +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +preemptionPolicy  +string + +priorityint32 +integer + +priorityClassName  +string +] +readinessGatesK +array> +< conditionType +object + + conditionType  +string + + restartPolicy  +string + +runtimeClassName  +string + + schedulerName  +string + +securityContext +object + +fsGroupint64 +integer +" +fsGroupChangePolicy  +string +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string +8 +supplementalGroups" +array +int64 +integer +b +sysctlsW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + +serviceAccount  +string +! +serviceAccountName  +string +! +setHostnameAsFQDN  +boolean +% +shareProcessNamespace  +boolean + + subdomain  +string +4 +terminationGracePeriodSecondsint64 +integer + + tolerations +array + +object + +effect  +string + +key  +string + +operator  +string +( +tolerationSecondsint64 +integer + +value  +string + +topologySpreadConstraints +array +maxSkew topologyKeywhenUnsatisfiable +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +maxSkewint32 +integer +! + +minDomainsint32 +integer + + topologyKey  +string + +whenUnsatisfiable  +stringB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap + += +volumes2/ +$x-kubernetes-preserve-unknown-fieldstrue + + + terminate  +boolean + +status +object + + analysisRuns +array + analysisRunnamephase +object_ + + analysisRun  +string + +message  +string + +name  +string + +phase  +string +% + availableAt date-time +string + + +conditions +array +lastTransitionTimelastUpdateTimemessagereasonstatustype +object +, +lastTransitionTime date-time +string +( +lastUpdateTime date-time +string + +message  +string + +reason  +string + +status  +string + +type  +string + +message  +string + +phase  +string + +templateStatuses +array +availableReplicasname readyReplicasreplicasupdatedReplicas +object +( +availableReplicasint32 +integer +% +collisionCountint32 +integer +, +lastTransitionTime date-time +string + +message  +string + +name  +string + +podTemplateHash  +string +$ + readyReplicasint32 +integer + +replicasint32 +integer + + serviceName  +string + +status  +string +& +updatedReplicasint32 +integera +x-kubernetes-group-version-kind><- group: argoproj.io + kind: Experiment + version: v1alpha1 + + +#io.argoproj.v1alpha1.ExperimentList "&ExperimentList is a list of Experimentitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"sList of experiments. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array1 +/ +-#/definitions/io.argoproj.v1alpha1.Experiment + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindse +x-kubernetes-group-version-kindB@- group: argoproj.io + kind: ExperimentList + version: v1alpha1 + + +io.argoproj.v1alpha1.Rolloutspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +object + +analysist +objectf +0 +successfulRunHistoryLimitint32 +integer +2 +unsuccessfulRunHistoryLimitint32 +integer +& +minReadySecondsint32 +integer + +paused  +boolean +% +progressDeadlineAbort  +boolean +. +progressDeadlineSecondsint32 +integer + +replicasint32 +integer +# + restartAt date-time +string ++ +revisionHistoryLimitint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +> +strategy> +object> + + blueGreen activeService +object +1 +abortScaleDownDelaySecondsint32 +integer +s +activeMetadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + + activeService  +string + + antiAffinity +object +i +/preferredDuringSchedulingIgnoredDuringExecution6weight +object + +weightint32 +integer += +.requiredDuringSchedulingIgnoredDuringExecution  +object +$ +autoPromotionEnabled  +boolean ++ +autoPromotionSecondsint32 +integer +: +maxUnavailable(% +x-kubernetes-int-or-stringtrue + + +postPromotionAnalysis +object + +args +array +name +object + +name  +string + +value  +string + + valueFromu +objectg +@ +fieldRef4 fieldPath +object + + fieldPath  +string +# +podTemplateHashValue  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string +e + templatesX +arrayK +I +object; + + clusterScope  +boolean + + templateName  +string + +prePromotionAnalysis +object + +args +array +name +object + +name  +string + +value  +string + + valueFromu +objectg +@ +fieldRef4 fieldPath +object + + fieldPath  +string +# +podTemplateHashValue  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string +e + templatesX +arrayK +I +object; + + clusterScope  +boolean + + templateName  +string +t +previewMetadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object +* +previewReplicaCountint32 +integer + +previewService  +string +2 +scaleDownDelayRevisionLimitint32 +integer +, +scaleDownDelaySecondsint32 +integer +. +canary. +object. +1 +abortScaleDownDelaySecondsint32 +integer + +analysis +object + +args +array +name +object + +name  +string + +value  +string + + valueFromu +objectg +@ +fieldRef4 fieldPath +object + + fieldPath  +string +# +podTemplateHashValue  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string +# + startingStepint32 +integer +e + templatesX +arrayK +I +object; + + clusterScope  +boolean + + templateName  +string + + antiAffinity +object +i +/preferredDuringSchedulingIgnoredDuringExecution6weight +object + +weightint32 +integer += +.requiredDuringSchedulingIgnoredDuringExecution  +object +s +canaryMetadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + + canaryService  +string +" +dynamicStableScale  +boolean +4 +maxSurge(% +x-kubernetes-int-or-stringtrue + +: +maxUnavailable(% +x-kubernetes-int-or-stringtrue + +n +pingPongb pingService pongService +object8 + + pingService  +string + + pongService  +string +2 +scaleDownDelayRevisionLimitint32 +integer +, +scaleDownDelaySecondsint32 +integer +s +stableMetadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + + stableService  +string + +steps +array + +object + +analysis +object + +args +array +name +object + +name  +string + +value  +string + + valueFromu +objectg +@ +fieldRef4 fieldPath +object + + fieldPath  +string +# +podTemplateHashValue  +string +O +dryRunE +array8 +6 +metricName +object + + +metricName  +string + +measurementRetentionk +array^ +\limit +metricName +object9 + +limitint32 +integer + + +metricName  +string +e + templatesX +arrayK +I +object; + + clusterScope  +boolean + + templateName  +string + + +experiment templates +object + +analyses +array +name templateName +object + +args +array +name +object + +name  +string + +value  +string + + valueFromu +objectg +@ +fieldRef4 fieldPath +object + + fieldPath  +string +# +podTemplateHashValue  +string + + clusterScope  +boolean + +name  +string +% +requiredForCompletion  +boolean + + templateName  +string + +duration  +string + + templates +array +namespecRef +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +name  +string + +replicasint32 +integer + +selector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +specRef  +string + +weightint32 +integer +M +pauseD +object6 +4 +duration(% +x-kubernetes-int-or-stringtrue + + +setCanaryScaler +objectd +" +matchTrafficWeight  +boolean + +replicasint32 +integer + +weightint32 +integer + +setHeaderRoute +object + +match +array + +headerName headerValue +object} + + +headerName  +string +` + headerValueQ +objectC + +exact  +string + +prefix  +string + +regex  +string + +name  +string + +setMirrorRoutename +object + +match +array + +object +l +headersaS +Q +objectC + +exact  +string + +prefix  +string + +regex  +string +object +[ +methodQ +objectC + +exact  +string + +prefix  +string + +regex  +string +Y +pathQ +objectC + +exact  +string + +prefix  +string + +regex  +string + +name  +string +! + +percentageint32 +integer + + setWeightint32 +integer + +trafficRouting +object + +albingress servicePort +object + +annotationPrefix  +string + +ingress  +string + + rootService  +string +" + servicePortint32 +integer + +stickinessConfigkdurationSecondsenabled +objectA +& +durationSecondsint64 +integer + +enabled  +boolean +O + +ambassadorAmappings +object( +& +mappings +array +  +string + +appMesh +object + +virtualNodeGroupcanaryVirtualNodeRefstableVirtualNodeRef +object +B +canaryVirtualNodeRef*name +object + +name  +string +B +stableVirtualNodeRef*name +object + +name  +string +b +virtualServicePname +object; + +name  +string +$ +routes +array +  +string + +istio +object + +destinationRulecanarySubsetNamenamestableSubsetName +objectW + +canarySubsetName  +string + +name  +string + +stableSubsetName  +string + +virtualServicename +object + +name  +string +$ +routes +array +  +string +o + tlsRoutesb +arrayU +S +objectE + +portint64 +integer +& +sniHosts +array +  +string + +virtualServices +array +name +object + +name  +string +$ +routes +array +  +string +o + tlsRoutesb +arrayU +S +objectE + +portint64 +integer +& +sniHosts +array +  +string +J + managedRoutes9 +array, +*name +object + +name  +string + +nginx stableIngress +object| +; +additionalIngressAnnotations +  +string +object + +annotationPrefix  +string + + stableIngress  +string +R +smiK +object= + + rootService  +string + +trafficSplitName  +string +a +traefikVweightedTraefikServiceName +object+ +) +weightedTraefikServiceName  +string + +template +object +m +metadataa +objectS +* + annotations +  +string +object +% +labels +  +string +object + +spec +containers +object +, +activeDeadlineSecondsint64 +integer + +affinity +object + + nodeAffinity +object + +/preferredDuringSchedulingIgnoredDuringExecution +array + +preferenceweight +object + + +preference +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecutionnodeSelectorTerms +object + +nodeSelectorTerms +array + +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + matchFields +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string + + podAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +podAntiAffinity + +object + + +/preferredDuringSchedulingIgnoredDuringExecution +array +podAffinityTermweight +object + +podAffinityTerm topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string + +weightint32 +integer + +.requiredDuringSchedulingIgnoredDuringExecution +array + topologyKey +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +namespaceSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object +( + +namespaces +array +  +string + + topologyKey  +string +, +automountServiceAccountToken  +boolean +0 + +containers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + + dnsConfig +object +) + nameservers +array +  +string +S +optionsH +array; +9 +object+ + +name  +string + +value  +string +& +searches +array +  +string + + dnsPolicy  +string +" +enableServiceLinks  +boolean +1 +ephemeralContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +" +targetContainerName  +string +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string +h + hostAliasesY +arrayL +J +object< +' + hostnames +array +  +string + +ip  +string + +hostIPC  +boolean + + hostNetwork  +boolean + +hostPID  +boolean + +hostname  +string +F +imagePullSecrets2 +array% +# +object + +name  +string +0 +initContainers0 +array0 +0name +object0 +" +args +array +  +string +% +command +array +  +string + +env +array +name +object + +name  +string + +value  +string + + valueFrom +object +j +configMapKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean +[ +fieldRefO fieldPath +object5 + + +apiVersion  +string + + fieldPath  +string + +resourceFieldRefresource +object + + containerName  +string + +divisorjq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + + +resource  +string +g + secretKeyRefWkey +objectC + +key  +string + +name  +string + +optional  +boolean + +envFrom +array + +object +M + configMapRef= +object/ + +name  +string + +optional  +boolean + +prefix  +string +J + secretRef= +object/ + +name  +string + +optional  +boolean + +image  +string + +imagePullPolicy  +string + + lifecycle +object + + postStart +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +preStop +object += +exec5 +object' +% +command +array +  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + + livenessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +name  +string + +ports +array + containerPort +object +$ + containerPortint32 +integer + +hostIP  +string + +hostPortint32 +integer + +name  +string + +protocol  +string; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap + + +readinessProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + + resources +object~ +< +limits2/ +$x-kubernetes-preserve-unknown-fieldstrue + +> +requests2/ +$x-kubernetes-preserve-unknown-fieldstrue + + +securityContext +object +( +allowPrivilegeEscalation  +boolean +e + capabilitiesU +objectG +! +add +array +  +string +" +drop +array +  +string + + +privileged  +boolean + + procMount  +string +& +readOnlyRootFilesystem  +boolean +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + + startupProbe +object += +exec5 +object' +% +command +array +  +string +' +failureThresholdint32 +integer +R +grpcJport +object5 + +portint32 +integer + +service  +string + +httpGetport +object + +host  +string +f + httpHeadersW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +path  +string +0 +port(% +x-kubernetes-int-or-stringtrue + + +scheme  +string +* +initialDelaySecondsint32 +integer +$ + periodSecondsint32 +integer +' +successThresholdint32 +integer +i + tcpSocket\port +objectG + +host  +string +0 +port(% +x-kubernetes-int-or-stringtrue + +4 +terminationGracePeriodSecondsint64 +integer +% +timeoutSecondsint32 +integer + +stdin  +boolean + + stdinOnce  +boolean +% +terminationMessagePath  +string +' +terminationMessagePolicy  +string + +tty  +boolean +r + volumeDevicesa +arrayT +R +devicePathname +object0 + + +devicePath  +string + +name  +string + + volumeMounts +array + mountPathname +object + + mountPath  +string + +mountPropagation  +string + +name  +string + +readOnly  +boolean + +subPath  +string + + subPathExpr  +string + + +workingDir  +string + +nodeName  +string +P + nodeSelector@ +  +string +object" +x-kubernetes-map-type atomic + +0 +os*name +object + +name  +string + +overhead +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + +preemptionPolicy  +string + +priorityint32 +integer + +priorityClassName  +string +] +readinessGatesK +array> +< conditionType +object + + conditionType  +string + + restartPolicy  +string + +runtimeClassName  +string + + schedulerName  +string + +securityContext +object + +fsGroupint64 +integer +" +fsGroupChangePolicy  +string +! + +runAsGroupint64 +integer + + runAsNonRoot  +boolean + + runAsUserint64 +integer +u +seLinuxOptionsc +objectU + +level  +string + +role  +string + +type  +string + +user  +string +] +seccompProfileKtype +object6 + +localhostProfile  +string + +type  +string +8 +supplementalGroups" +array +int64 +integer +b +sysctlsW +arrayJ +Hnamevalue +object+ + +name  +string + +value  +string + +windowsOptions +object +! +gmsaCredentialSpec  +string +% +gmsaCredentialSpecName  +string + + hostProcess  +boolean + + runAsUserName  +string + +serviceAccount  +string +! +serviceAccountName  +string +! +setHostnameAsFQDN  +boolean +% +shareProcessNamespace  +boolean + + subdomain  +string +4 +terminationGracePeriodSecondsint64 +integer + + tolerations +array + +object + +effect  +string + +key  +string + +operator  +string +( +tolerationSecondsint64 +integer + +value  +string + +topologySpreadConstraints +array +maxSkew topologyKeywhenUnsatisfiable +object + + labelSelector +object + +matchExpressions +arrayt +rkeyoperator +objectS + +key  +string + +operator  +string +$ +values +array +  +string +* + matchLabels +  +string +object + +maxSkewint32 +integer +! + +minDomainsint32 +integer + + topologyKey  +string + +whenUnsatisfiable  +stringB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap + +L +volumesA +array4 +2/ +$x-kubernetes-preserve-unknown-fieldstrue + +b + workloadRefS +objectE + + +apiVersion  +string + +kind  +string + +name  +string + +status +object +" + HPAReplicasint32 +integer + +abort  +boolean +# + abortedAt date-time +string + +alb +object +Y +canaryTargetGroupDarnname +object) + +arn  +string + +name  +string +T + loadBalancerDarnname +object) + +arn  +string + +name  +string +Y +stableTargetGroupDarnname +object) + +arn  +string + +name  +string +( +availableReplicasint32 +integer + + blueGreen +object + +activeSelector  +string + +postPromotionAnalysisRunStatusbnamestatus +objectD + +message  +string + +name  +string + +status  +string + +prePromotionAnalysisRunStatusbnamestatus +objectD + +message  +string + +name  +string + +status  +string + +previewSelector  +string +( +scaleUpPreviewCheckPoint  +boolean + +canary +object + +"currentBackgroundAnalysisRunStatusbnamestatus +objectD + +message  +string + +name  +string + +status  +string + +currentExperiment  +string + +currentStepAnalysisRunStatusbnamestatus +objectD + +message  +string + +name  +string + +status  +string + +stablePingPong  +string + +weightscanarystable +object + + +additional +arrayt +rweight +object[ + +podTemplateHash  +string + + serviceName  +string + +weightint32 +integer +| +canaryrweight +object[ + +podTemplateHash  +string + + serviceName  +string + +weightint32 +integer +| +stablerweight +object[ + +podTemplateHash  +string + + serviceName  +string + +weightint32 +integer + +verified  +boolean +% +collisionCountint32 +integer + + +conditions +array +lastTransitionTimelastUpdateTimemessagereasonstatustype +object +, +lastTransitionTime date-time +string +( +lastUpdateTime date-time +string + +message  +string + +reason  +string + +status  +string + +type  +string + +controllerPause  +boolean + +currentPodHash  +string + +currentStepHash  +string +' +currentStepIndexint32 +integer + +message  +string +! +observedGeneration  +string + +pauseConditionsn +arraya +_reason startTime +object< + +reason  +string +# + startTime date-time +string + +phase  +string + + promoteFull  +boolean +$ + readyReplicasint32 +integer + +replicasint32 +integer +% + restartedAt date-time +string + +selector  +string + +stableRS  +string +& +updatedReplicasint32 +integer +) +workloadObservedGeneration  +string^ +x-kubernetes-group-version-kind;9- group: argoproj.io + kind: Rollout + version: v1alpha1 + + + io.argoproj.v1alpha1.RolloutList " RolloutList is a list of Rolloutitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"pList of rollouts. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array. +, +*#/definitions/io.argoproj.v1alpha1.Rollout + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsb +x-kubernetes-group-version-kind?=- group: argoproj.io + kind: RolloutList + version: v1alpha1 + +4 +3io.k8s.api.admissionregistration.v1.MutatingWebhook3"^MutatingWebhook describes an admission webhook and the resources and operations it applies to.name clientConfig sideEffectsadmissionReviewVersions +object2 + +admissionReviewVersions"AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. +array +  +string + + clientConfig +E#/definitions/io.k8s.api.admissionregistration.v1.WebhookClientConfig"?ClientConfig defines how to communicate with the hook. Required + + failurePolicy"FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. +string + + matchPolicy"matchPolicy defines how the "rules" list is used to match incoming requests. Allowed values are "Exact" or "Equivalent". + +- Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but "rules" only included `apiGroups:["apps"], apiVersions:["v1"], resources: ["deployments"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. + +- Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and "rules" only included `apiGroups:["apps"], apiVersions:["v1"], resources: ["deployments"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. + +Defaults to "Equivalent" +string + +name"The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where "imagepolicy" is the name of the webhook, and kubernetes.io is the name of the organization. Required. +string + +namespaceSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" NamespaceSelector decides whether to run the webhook on an object based on whether the namespace for that object matches the selector. If the object itself is a namespace, the matching is performed on object.metadata.labels. If the object is another cluster scoped resource, it never skips the webhook. + +For example, to run the webhook on any objects whose namespace is not associated with "runlevel" of "0" or "1"; you will set the selector as follows: "namespaceSelector": { + "matchExpressions": [ + { + "key": "runlevel", + "operator": "NotIn", + "values": [ + "0", + "1" + ] + } + ] +} + +If instead you want to only run the webhook on any objects whose namespace is associated with the "environment" of "prod" or "staging"; you will set the selector as follows: "namespaceSelector": { + "matchExpressions": [ + { + "key": "environment", + "operator": "In", + "values": [ + "prod", + "staging" + ] + } + ] +} + +See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ for more examples of label selectors. + +Default to the empty LabelSelector, which matches everything. + +objectSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"ObjectSelector decides whether to run the webhook based on if the object has matching labels. objectSelector is evaluated against both the oldObject and newObject that would be sent to the webhook, and is considered to match if either object matches the selector. A null object (oldObject in the case of create, or newObject in the case of delete) or an object that cannot have labels (like a DeploymentRollback or a PodProxyOptions object) is not considered to match. Use the object selector only if the webhook is opt-in, because end users may skip the admission webhook by setting the labels. Default to the empty LabelSelector, which matches everything. + +reinvocationPolicy"reinvocationPolicy indicates whether this webhook should be called multiple times as part of a single admission evaluation. Allowed values are "Never" and "IfNeeded". + +Never: the webhook will not be called more than once in a single admission evaluation. + +IfNeeded: the webhook will be called at least one additional time as part of the admission evaluation if the object being admitted is modified by other admission plugins after the initial webhook call. Webhooks that specify this option *must* be idempotent, able to process objects they previously admitted. Note: * the number of additional invocations is not guaranteed to be exactly one. * if additional invocations result in further modifications to the object, webhooks are not guaranteed to be invoked again. * webhooks that use this option may be reordered to minimize the number of additional invocations. * to validate an object after all mutations are guaranteed complete, use a validating admission webhook instead. + +Defaults to "Never". +string + +rules"Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. +arrayH +F +D#/definitions/io.k8s.api.admissionregistration.v1.RuleWithOperations + + sideEffects"SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission chain and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. +string + +timeoutSecondsint32"TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. +integer + +@io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration +"MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata. + +webhooks"IWebhooks is a list of webhooks and the affected resources and operations. +arrayE +C +A#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhook' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge +~ +x-kubernetes-group-version-kind[Y- group: admissionregistration.k8s.io + kind: MutatingWebhookConfiguration + version: v1 + + + +Dio.k8s.api.admissionregistration.v1.MutatingWebhookConfigurationList "KMutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"%List of MutatingWebhookConfiguration. +arrayR +P +N#/definitions/io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +x-kubernetes-group-version-kind_]- group: admissionregistration.k8s.io + kind: MutatingWebhookConfigurationList + version: v1 + + +6io.k8s.api.admissionregistration.v1.RuleWithOperations "RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. +object + + apiGroups"APIGroups is the API groups the resources belong to. '*' is all groups. If '*' is present, the length of the slice must be one. Required. +array +  +string + + apiVersions"APIVersions is the API versions the resources belong to. '*' is all versions. If '*' is present, the length of the slice must be one. Required. +array +  +string + + +operations"Operations is the operations the admission hook cares about - CREATE, UPDATE, DELETE, CONNECT or * for all of those operations and any future admission operations that are added. If '*' is present, the length of the slice must be one. Required. +array +  +string + + resources"Resources is a list of resources this rule applies to. + +For example: 'pods' means pods. 'pods/log' means the log subresource of pods. '*' means all resources, but not subresources. 'pods/*' means all subresources of pods. '*/scale' means all scale subresources. '*/*' means all resources and their subresources. + +If wildcard is present, the validation rule will ensure resources do not overlap with each other. + +Depending on the enclosing object, subresources might not be allowed. Required. +array +  +string + +scope"scope specifies the scope of this rule. Valid values are "Cluster", "Namespaced", and "*" "Cluster" means that only cluster-scoped resources will match this rule. Namespace API objects are cluster-scoped. "Namespaced" means that only namespaced resources will match this rule. "*" means that there are no scope restrictions. Subresources match the scope of their parent resource. Default is "*". +string + +4io.k8s.api.admissionregistration.v1.ServiceReference";ServiceReference holds a reference to Service.legacy.k8s.io namespacename +object +@ +name8"+`name` is the name of the service. Required +string +O + namespaceB"5`namespace` is the namespace of the service. Required +string +f +path^"Q`path` is an optional URL path which will be sent in any request to this service. +string + +portint32"If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). +integer +, +5io.k8s.api.admissionregistration.v1.ValidatingWebhook+"`ValidatingWebhook describes an admission webhook and the resources and operations it applies to.name clientConfig sideEffectsadmissionReviewVersions +object* + +admissionReviewVersions"AdmissionReviewVersions is an ordered list of preferred `AdmissionReview` versions the Webhook expects. API server will try to use first version in the list which it supports. If none of the versions specified in this list supported by API server, validation will fail for this object. If a persisted webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail and be subject to the failure policy. +array +  +string + + clientConfig +E#/definitions/io.k8s.api.admissionregistration.v1.WebhookClientConfig"?ClientConfig defines how to communicate with the hook. Required + + failurePolicy"FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Fail. +string + + matchPolicy"matchPolicy defines how the "rules" list is used to match incoming requests. Allowed values are "Exact" or "Equivalent". + +- Exact: match a request only if it exactly matches a specified rule. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, but "rules" only included `apiGroups:["apps"], apiVersions:["v1"], resources: ["deployments"]`, a request to apps/v1beta1 or extensions/v1beta1 would not be sent to the webhook. + +- Equivalent: match a request if modifies a resource listed in rules, even via another API group or version. For example, if deployments can be modified via apps/v1, apps/v1beta1, and extensions/v1beta1, and "rules" only included `apiGroups:["apps"], apiVersions:["v1"], resources: ["deployments"]`, a request to apps/v1beta1 or extensions/v1beta1 would be converted to apps/v1 and sent to the webhook. + +Defaults to "Equivalent" +string + +name"The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where "imagepolicy" is the name of the webhook, and kubernetes.io is the name of the organization. Required. +string + +namespaceSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector" NamespaceSelector decides whether to run the webhook on an object based on whether the namespace for that object matches the selector. If the object itself is a namespace, the matching is performed on object.metadata.labels. If the object is another cluster scoped resource, it never skips the webhook. + +For example, to run the webhook on any objects whose namespace is not associated with "runlevel" of "0" or "1"; you will set the selector as follows: "namespaceSelector": { + "matchExpressions": [ + { + "key": "runlevel", + "operator": "NotIn", + "values": [ + "0", + "1" + ] + } + ] +} + +If instead you want to only run the webhook on any objects whose namespace is associated with the "environment" of "prod" or "staging"; you will set the selector as follows: "namespaceSelector": { + "matchExpressions": [ + { + "key": "environment", + "operator": "In", + "values": [ + "prod", + "staging" + ] + } + ] +} + +See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels for more examples of label selectors. + +Default to the empty LabelSelector, which matches everything. + +objectSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"ObjectSelector decides whether to run the webhook based on if the object has matching labels. objectSelector is evaluated against both the oldObject and newObject that would be sent to the webhook, and is considered to match if either object matches the selector. A null object (oldObject in the case of create, or newObject in the case of delete) or an object that cannot have labels (like a DeploymentRollback or a PodProxyOptions object) is not considered to match. Use the object selector only if the webhook is opt-in, because end users may skip the admission webhook by setting the labels. Default to the empty LabelSelector, which matches everything. + +rules"Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. +arrayH +F +D#/definitions/io.k8s.api.admissionregistration.v1.RuleWithOperations + + sideEffects"SideEffects states whether this webhook has side effects. Acceptable values are: None, NoneOnDryRun (webhooks created via v1beta1 may also specify Some or Unknown). Webhooks with side effects MUST implement a reconciliation system, since a request may be rejected by a future step in the admission chain and the side effects therefore need to be undone. Requests with the dryRun attribute will be auto-rejected if they match a webhook with sideEffects == Unknown or Some. +string + +timeoutSecondsint32"TimeoutSeconds specifies the timeout for this webhook. After the timeout passes, the webhook call will be ignored or the API call will fail based on the failure policy. The timeout value must be between 1 and 30 seconds. Default to 10 seconds. +integer + +Bio.k8s.api.admissionregistration.v1.ValidatingWebhookConfiguration +"ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata. + +webhooks"IWebhooks is a list of webhooks and the affected resources and operations. +arrayG +E +C#/definitions/io.k8s.api.admissionregistration.v1.ValidatingWebhook' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + +x-kubernetes-group-version-kind][- group: admissionregistration.k8s.io + kind: ValidatingWebhookConfiguration + version: v1 + + + +Fio.k8s.api.admissionregistration.v1.ValidatingWebhookConfigurationList "OValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"'List of ValidatingWebhookConfiguration. +arrayT +R +P#/definitions/io.k8s.api.admissionregistration.v1.ValidatingWebhookConfiguration + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +x-kubernetes-group-version-kinda_- group: admissionregistration.k8s.io + kind: ValidatingWebhookConfigurationList + version: v1 + + +7io.k8s.api.admissionregistration.v1.WebhookClientConfig "VWebhookClientConfig contains the information to make a TLS connection with the webhook +object + +caBundlebyte"`caBundle` is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. +string + +service +B#/definitions/io.k8s.api.admissionregistration.v1.ServiceReference"`service` is a reference to the service for this webhook. Either `service` or `url` must be specified. + +If the webhook is running within the cluster, then you should use `service`. + +url"`url` gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. + +The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. + +Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. + +The scheme must be "https"; the URL must begin with "https://". + +A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. + +Attempting to use a user or basic auth e.g. "user:password@" is not allowed. Fragments ("#...") and query parameters ("?...") are not allowed, either. +string + +%io.k8s.api.apps.v1.ControllerRevision"ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers.revision +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +y +dataq +:#/definitions/io.k8s.apimachinery.pkg.runtime.RawExtension"3Data is the serialized representation of the state. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +b +revisionVint64"ARevision indicates the revision of the state represented by Data. +integer\ +x-kubernetes-group-version-kind97- group: apps + kind: ControllerRevision + version: v1 + + +)io.k8s.api.apps.v1.ControllerRevisionList"UControllerRevisionList is a resource containing a list of ControllerRevision objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +w +itemsn"(Items is the list of ControllerRevisions +array7 +5 +3#/definitions/io.k8s.api.apps.v1.ControllerRevision + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"gMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata` +x-kubernetes-group-version-kind=;- group: apps + kind: ControllerRevisionList + version: v1 + + +io.k8s.api.apps.v1.DaemonSet "7DaemonSet represents the configuration of a daemon set. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +.#/definitions/io.k8s.api.apps.v1.DaemonSetSpec"The desired behavior of this daemon set. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +0#/definitions/io.k8s.api.apps.v1.DaemonSetStatus"The current status of this daemon set. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusS +x-kubernetes-group-version-kind0.- group: apps + kind: DaemonSet + version: v1 + + +%io.k8s.api.apps.v1.DaemonSetCondition"IDaemonSetCondition describes the state of a DaemonSet at a certain point.typestatus +object + +lastTransitionTime{ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"@Last time the condition transitioned from one status to another. +Y +messageN"AA human readable message indicating details about the transition. +string +F +reason<"/The reason for the condition's last transition. +string +L +statusB"5Status of the condition, one of True, False, Unknown. +string +1 +type)"Type of DaemonSet condition. +string + + io.k8s.api.apps.v1.DaemonSetList"-DaemonSetList is a collection of daemon sets.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +\ +itemsS"A list of daemon sets. +array. +, +*#/definitions/io.k8s.api.apps.v1.DaemonSet + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataW +x-kubernetes-group-version-kind42- group: apps + kind: DaemonSetList + version: v1 + + + io.k8s.api.apps.v1.DaemonSetSpec "3DaemonSetSpec is the specification of a daemon set.selectortemplate +object + + +minReadySecondsint32"The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). +integer + +revisionHistoryLimitint32"The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. +integer + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"A label query over pods that are managed by the daemon set. Must match in order to be controlled. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"An object that describes the pod that will be created. The DaemonSet will create exactly one copy of this pod on every node that matches the template's node selector (or on every node if no node selector is specified). More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template + +updateStrategy +8#/definitions/io.k8s.api.apps.v1.DaemonSetUpdateStrategy"DAn update strategy to replace existing DaemonSet pods with new pods. + +"io.k8s.api.apps.v1.DaemonSetStatus">DaemonSetStatus represents the current status of a daemon set.currentNumberSchedulednumberMisscheduleddesiredNumberScheduled numberReady +object + +collisionCountint32"Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. +integer + + +conditions"LRepresents the latest available observations of a DaemonSet's current state. +array7 +5 +3#/definitions/io.k8s.api.apps.v1.DaemonSetCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +currentNumberScheduledint32"The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ +integer + +desiredNumberScheduledint32"The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ +integer + +numberAvailableint32"The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) +integer + +numberMisscheduledint32"The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ +integer + + numberReadyint32"numberReady is the number of nodes that should be running the daemon pod and have one or more of the daemon pod running with a Ready Condition. +integer + +numberUnavailableint32"The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) +integer +l +observedGenerationVint64"AThe most recent generation observed by the daemon set controller. +integer +l +updatedNumberScheduledRint32"=The total number of nodes that are running updated daemon pod +integer + +*io.k8s.api.apps.v1.DaemonSetUpdateStrategy"XDaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. +object + + rollingUpdate +7#/definitions/io.k8s.api.apps.v1.RollingUpdateDaemonSet"ERolling update config params. Present only if type = "RollingUpdate". + +type"Type of daemon set update. Can be "RollingUpdate" or "OnDelete". Default is RollingUpdate. + +Possible enum values: + - `"OnDelete"` Replace the old daemons only when it's killed + - `"RollingUpdate"` Replace the old daemons by new ones using rolling update i.e replace them on each node one after the other.  OnDelete +RollingUpdate + +string + + +io.k8s.api.apps.v1.Deployment "@Deployment enables declarative updates for Pods and ReplicaSets. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +s +speck +/#/definitions/io.k8s.api.apps.v1.DeploymentSpec"8Specification of the desired behavior of the Deployment. +o +statuse +1#/definitions/io.k8s.api.apps.v1.DeploymentStatus"0Most recently observed status of the Deployment.T +x-kubernetes-group-version-kind1/- group: apps + kind: Deployment + version: v1 + + +&io.k8s.api.apps.v1.DeploymentCondition"KDeploymentCondition describes the state of a deployment at a certain point.typestatus +object + +lastTransitionTime{ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"@Last time the condition transitioned from one status to another. +v +lastUpdateTimed +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time")The last time this condition was updated. +Y +messageN"AA human readable message indicating details about the transition. +string +F +reason<"/The reason for the condition's last transition. +string +L +statusB"5Status of the condition, one of True, False, Unknown. +string +2 +type*"Type of deployment condition. +string + +!io.k8s.api.apps.v1.DeploymentList"(DeploymentList is a list of Deployments.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +h +items_"!Items is the list of Deployments. +array/ +- ++#/definitions/io.k8s.api.apps.v1.Deployment + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +b +metadataV +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata.X +x-kubernetes-group-version-kind53- group: apps + kind: DeploymentList + version: v1 + + +!io.k8s.api.apps.v1.DeploymentSpec "NDeploymentSpec is the specification of the desired behavior of the Deployment.selectortemplate +object + +minReadySecondsint32"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) +integer +@ +paused6"(Indicates that the deployment is paused. +boolean + +progressDeadlineSecondsint32"The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. +integer + +replicasint32"pNumber of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. +integer + +revisionHistoryLimitint32"The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. +integer + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Label selector for pods. Existing ReplicaSets whose pods are selected by this will be the ones affected by this deployment. It must match the pod template's labels. + +strategy +3#/definitions/io.k8s.api.apps.v1.DeploymentStrategy"FThe deployment strategy to use to replace existing pods with new ones., +x-kubernetes-patch-strategy  retainKeys + +q +templatee +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"1Template describes the pods that will be created. + +#io.k8s.api.apps.v1.DeploymentStatus "HDeploymentStatus is the most recently observed status of the Deployment. +object + +availableReplicasuint32"`Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. +integer + +collisionCountint32"Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. +integer + + +conditions"MRepresents the latest available observations of a deployment's current state. +array8 +6 +4#/definitions/io.k8s.api.apps.v1.DeploymentCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + +` +observedGenerationJint64"5The generation observed by the deployment controller. +integer +} + readyReplicaslint32"WreadyReplicas is the number of pods targeted by this Deployment with a Ready Condition. +integer + +replicaswint32"bTotal number of non-terminated pods targeted by this deployment (their labels match the selector). +integer + +unavailableReplicasint32"Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. +integer + +updatedReplicasyint32"dTotal number of non-terminated pods targeted by this deployment that have the desired template spec. +integer + +%io.k8s.api.apps.v1.DeploymentStrategy"HDeploymentStrategy describes how to replace existing pods with new ones. +object + + rollingUpdate +8#/definitions/io.k8s.api.apps.v1.RollingUpdateDeployment"URolling update config params. Present only if DeploymentStrategyType = RollingUpdate. + +type"Type of deployment. Can be "Recreate" or "RollingUpdate". Default is RollingUpdate. + +Possible enum values: + - `"Recreate"` Kill all existing pods before creating new ones. + - `"RollingUpdate"` Replace the old ReplicaSets by new one using rolling update i.e gradually scale down the old ReplicaSets and scale up the new one.  Recreate +RollingUpdate + +string + +io.k8s.api.apps.v1.ReplicaSet "YReplicaSet ensures that a specified number of pod replicas are running at any given time. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"If the Labels of a ReplicaSet are empty, they are defaulted to be the same as the Pod(s) that the ReplicaSet manages. Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +/#/definitions/io.k8s.api.apps.v1.ReplicaSetSpec"Spec defines the specification of the desired behavior of the ReplicaSet. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +1#/definitions/io.k8s.api.apps.v1.ReplicaSetStatus"Status is the most recently observed status of the ReplicaSet. This data may be out of date by some window of time. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusT +x-kubernetes-group-version-kind1/- group: apps + kind: ReplicaSet + version: v1 + + +&io.k8s.api.apps.v1.ReplicaSetCondition"LReplicaSetCondition describes the state of a replica set at a certain point.typestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"DThe last time the condition transitioned from one status to another. +Y +messageN"AA human readable message indicating details about the transition. +string +F +reason<"/The reason for the condition's last transition. +string +L +statusB"5Status of the condition, one of True, False, Unknown. +string +3 +type+"Type of replica set condition. +string + +!io.k8s.api.apps.v1.ReplicaSetList ".ReplicaSetList is a collection of ReplicaSets.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"oList of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller +array/ +- ++#/definitions/io.k8s.api.apps.v1.ReplicaSet + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsX +x-kubernetes-group-version-kind53- group: apps + kind: ReplicaSetList + version: v1 + + + +!io.k8s.api.apps.v1.ReplicaSetSpec +"4ReplicaSetSpec is the specification of a ReplicaSet.selector +object + +minReadySecondsint32"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) +integer + +replicasint32"Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller +integer + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Selector is a label query over pods that should match the replica count. Label keys and values that must match in order to be controlled by this replica set. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"Template is the object that describes the pod that will be created if insufficient replicas are detected. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template + +#io.k8s.api.apps.v1.ReplicaSetStatus"?ReplicaSetStatus represents the current status of a ReplicaSet.replicas +object + +availableReplicaspint32"[The number of available replicas (ready for at least minReadySeconds) for this replica set. +integer + + +conditions"NRepresents the latest available observations of a replica set's current state. +array8 +6 +4#/definitions/io.k8s.api.apps.v1.ReplicaSetCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +fullyLabeledReplicassint32"^The number of pods that have labels matching the labels of the pod template of the replicaset. +integer + +observedGenerationiint64"TObservedGeneration reflects the generation of the most recently observed ReplicaSet. +integer +} + readyReplicaslint32"WreadyReplicas is the number of pods targeted by this ReplicaSet with a Ready Condition. +integer + +replicasint32"Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller +integer + +)io.k8s.api.apps.v1.RollingUpdateDaemonSet"BSpec to control the desired behavior of daemon set rolling update. +object + + +maxSurge + +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString" +The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. This is beta field and enabled/disabled by DaemonSetUpdateSurge feature gate. + +maxUnavailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update. + +*io.k8s.api.apps.v1.RollingUpdateDeployment "7Spec to control the desired behavior of rolling update. +object + +maxSurge +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"The maximum number of pods that can be scheduled above the desired number of pods. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up. Defaults to 25%. Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update starts, such that the total number of old and new pods do not exceed 130% of desired pods. Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that total number of pods running at any time during the update is at most 130% of desired pods. + +maxUnavailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding down. This can not be 0 if MaxSurge is 0. Defaults to 25%. Example: when this is set to 30%, the old ReplicaSet can be scaled down to 70% of desired pods immediately when the rolling update starts. Once new pods are ready, old ReplicaSet can be scaled down further, followed by scaling up the new ReplicaSet, ensuring that the total number of pods available at all times during the update is at least 70% of desired pods. + +3io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy"kRollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. +object + +maxUnavailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"The maximum number of pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). Absolute number is calculated from percentage by rounding up. This can not be 0. Defaults to 1. This field is alpha-level and is only honored by servers that enable the MaxUnavailableStatefulSet feature. The field applies to all pods in the range 0 to Replicas-1. That means if there is any unavailable pod in the range 0 to Replicas-1, it will be counted towards MaxUnavailable. + + partitionint32"Partition indicates the ordinal at which the StatefulSet should be partitioned for updates. During a rolling update, all pods from ordinal Replicas-1 to Partition are updated. All pods from ordinal Partition-1 to 0 remain untouched. This is helpful in being able to do a canary based deployment. The default value is 0. +integer + +io.k8s.api.apps.v1.StatefulSet "StatefulSet represents a set of pods with consistent identities. Identities are defined as: + - Network: A single stable DNS and hostname. + - Storage: As many VolumeClaims as requested. +The StatefulSet guarantees that a given network identity will always map to the same storage identity. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +t +specl +0#/definitions/io.k8s.api.apps.v1.StatefulSetSpec"8Spec defines the desired identities of pods in this set. + +status +2#/definitions/io.k8s.api.apps.v1.StatefulSetStatus"nStatus is the current status of Pods in this StatefulSet. This data may be out of date by some window of time.U +x-kubernetes-group-version-kind20- group: apps + kind: StatefulSet + version: v1 + + +'io.k8s.api.apps.v1.StatefulSetCondition"MStatefulSetCondition describes the state of a statefulset at a certain point.typestatus +object + +lastTransitionTime{ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"@Last time the condition transitioned from one status to another. +Y +messageN"AA human readable message indicating details about the transition. +string +F +reason<"/The reason for the condition's last transition. +string +L +statusB"5Status of the condition, one of True, False, Unknown. +string +3 +type+"Type of statefulset condition. +string + +"io.k8s.api.apps.v1.StatefulSetList"0StatefulSetList is a collection of StatefulSets.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +k +itemsb"#Items is the list of stateful sets. +array0 +. +,#/definitions/io.k8s.api.apps.v1.StatefulSet + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataY +x-kubernetes-group-version-kind64- group: apps + kind: StatefulSetList + version: v1 + + +Bio.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy"StatefulSetPersistentVolumeClaimRetentionPolicy describes the policy used for PVCs created from the StatefulSet VolumeClaimTemplates. +object + + whenDeleted"WhenDeleted specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is deleted. The default policy of `Retain` causes PVCs to not be affected by StatefulSet deletion. The `Delete` policy causes those PVCs to be deleted. +string + + +whenScaled"WhenScaled specifies what happens to PVCs created from StatefulSet VolumeClaimTemplates when the StatefulSet is scaled down. The default policy of `Retain` causes PVCs to not be affected by a scaledown. The `Delete` policy causes the associated PVCs for any excess pods above the replica count to be deleted. +string +" +"io.k8s.api.apps.v1.StatefulSetSpec""8A StatefulSetSpec is the specification of a StatefulSet.selectortemplate serviceName +object! + +minReadySecondsint32"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate. +integer + +$persistentVolumeClaimRetentionPolicy +P#/definitions/io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy"persistentVolumeClaimRetentionPolicy describes the lifecycle of persistent volume claims created from volumeClaimTemplates. By default, all persistent volume claims are created as needed and retained until manually deleted. This policy allows the lifecycle to be altered, for example by deleting persistent volume claims when their stateful set is deleted, or when their pod is scaled down. This requires the StatefulSetAutoDeletePVC feature gate to be enabled, which is alpha. +optional + +podManagementPolicy"podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. + +Possible enum values: + - `"OrderedReady"` will create pods in strictly increasing order on scale up and strictly decreasing order on scale down, progressing only when the previous pod is ready or terminated. At most one pod will be changed at any time. + - `"Parallel"` will create and delete pods as soon as the stateful set replica count is changed, and will not wait for pods to be ready or complete termination. OrderedReady +  Parallel + +string + +replicasint32"replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. +integer + +revisionHistoryLimitint32"revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet's revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. +integer + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"selector is a label query over pods that should match the replica count. It must match the pod template's labels. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + + serviceName"serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where "pod-specific-string" is managed by the StatefulSet controller. +string + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"template is the object that describes the pod that will be created if insufficient replicas are detected. Each pod stamped out by the StatefulSet will fulfill this Template, but have a unique identity from the rest of the StatefulSet. + +updateStrategy +:#/definitions/io.k8s.api.apps.v1.StatefulSetUpdateStrategy"updateStrategy indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template. + +volumeClaimTemplates"volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. +array: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +$io.k8s.api.apps.v1.StatefulSetStatus"@StatefulSetStatus represents the current state of a StatefulSet.replicas +object + +availableReplicasint32"Total number of available pods (ready for at least minReadySeconds) targeted by this statefulset. This is a beta field and enabled/disabled by StatefulSetMinReadySeconds feature gate. +integer + +collisionCountint32"collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. +integer + + +conditions"NRepresents the latest available observations of a statefulset's current state. +array9 +7 +5#/definitions/io.k8s.api.apps.v1.StatefulSetCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +currentReplicasint32"currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. +integer + +currentRevision"currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). +string + +observedGenerationint64"observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet's generation, which is updated on mutation by the API Server. +integer +~ + readyReplicasmint32"XreadyReplicas is the number of pods created for this StatefulSet with a Ready Condition. +integer +f +replicasZint32"Ereplicas is the number of Pods created by the StatefulSet controller. +integer + +updateRevision"updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) +string + +updatedReplicasint32"updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. +integer + +,io.k8s.api.apps.v1.StatefulSetUpdateStrategy "StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. +object + + rollingUpdate +A#/definitions/io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy"bRollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType. + +type"Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate. + +Possible enum values: + - `"OnDelete"` triggers the legacy behavior. Version tracking and ordered rolling restarts are disabled. Pods are recreated from the StatefulSetSpec when they are manually deleted. When a scale operation is performed with this strategy,specification version indicated by the StatefulSet's currentRevision. + - `"RollingUpdate"` indicates that update will be applied to all Pods in the StatefulSet with respect to the StatefulSet ordering constraints. When a scale operation is performed with this strategy, new Pods will be created from the specification version indicated by the StatefulSet's updateRevision.  OnDelete +RollingUpdate + +string + +1io.k8s.api.authentication.v1.BoundObjectReference"JBoundObjectReference is a reference to an object that a token is bound to. +object +7 + +apiVersion)"API version of the referent. +string +N +kindF"9Kind of the referent. Valid kinds are 'Pod' and 'Secret'. +string +* +name""Name of the referent. +string +( +uid!"UID of the referent. +string + + +)io.k8s.api.authentication.v1.TokenRequest +":TokenRequest requests a token for a given service account.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specw +;#/definitions/io.k8s.api.authentication.v1.TokenRequestSpec"8Spec holds information about the request being evaluated + +status +=#/definitions/io.k8s.api.authentication.v1.TokenRequestStatus"WStatus is filled in by the server and indicates whether the token can be authenticated.g +x-kubernetes-group-version-kindDB- group: authentication.k8s.io + kind: TokenRequest + version: v1 + + +-io.k8s.api.authentication.v1.TokenRequestSpec "HTokenRequestSpec contains client provided parameters of a token request. audiences +object + + audiences"Audiences are the intendend audiences of the token. A recipient of a token must identitfy themself with an identifier in the list of audiences of the token, and otherwise should reject the token. A token issued for multiple audiences may be used to authenticate against any of the audiences listed but implies a high degree of trust between the target audiences. +array +  +string + +boundObjectRef +?#/definitions/io.k8s.api.authentication.v1.BoundObjectReference"BoundObjectRef is a reference to an object that the token will be bound to. The token will only be valid for as long as the bound object exists. NOTE: The API server's TokenReview endpoint will validate the BoundObjectRef, but other audiences may not. Keep ExpirationSeconds small if you want prompt revocation. + +expirationSecondsint64"ExpirationSeconds is the requested duration of validity of the request. The token issuer may return a token with a different validity duration so a client needs to check the 'expiration' field in a response. +integer + +/io.k8s.api.authentication.v1.TokenRequestStatus"4TokenRequestStatus is the result of a token request.tokenexpirationTimestamp +object + +expirationTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"DExpirationTimestamp is the time of expiration of the returned token. +7 +token."!Token is the opaque bearer token. +string + +(io.k8s.api.authentication.v1.TokenReview "TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +~ +specv +:#/definitions/io.k8s.api.authentication.v1.TokenReviewSpec"8Spec holds information about the request being evaluated + +status +<#/definitions/io.k8s.api.authentication.v1.TokenReviewStatus"YStatus is filled in by the server and indicates whether the request can be authenticated.f +x-kubernetes-group-version-kindCA- group: authentication.k8s.io + kind: TokenReview + version: v1 + + +,io.k8s.api.authentication.v1.TokenReviewSpec"ETokenReviewSpec is a description of the token authentication request. +object + + audiences"Audiences is a list of the identifiers that the resource server presented with the token identifies as. Audience-aware token authenticators will verify that the token was intended for at least one of the audiences in this list. If no audiences are provided, the audience will default to the audience of the Kubernetes apiserver. +array +  +string +7 +token."!Token is the opaque bearer token. +string + +.io.k8s.api.authentication.v1.TokenReviewStatus"DTokenReviewStatus is the result of the token authentication request. +object + + audiences"Audiences are audience identifiers chosen by the authenticator that are compatible with both the TokenReview and token. An identifier is any identifier in the intersection of the TokenReviewSpec audiences and the token's audiences. A client of the TokenReview API that sets the spec.audiences field should validate that a compatible audience identifier is returned in the status.audiences field to ensure that the TokenReview server is audience aware. If a TokenReview returns an empty status.audience field where status.authenticated is "true", the token is valid against the audience of the Kubernetes API server. +array +  +string +g + authenticatedV"HAuthenticated indicates that the token was associated with a known user. +boolean +H +error?"2Error indicates that the token couldn't be checked +string +w +usero +3#/definitions/io.k8s.api.authentication.v1.UserInfo"8User is the UserInfo associated with the provided token. + +%io.k8s.api.authentication.v1.UserInfo"ZUserInfo holds the information about the user needed to implement the user.Info interface. +object +n +extrae"9Any additional information provided by the authenticator. + +array +  +string +object +Q +groupsG"+The names of groups this user is a part of. +array +  +string + +uid"A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. +string +\ +usernameP"CThe name that uniquely identifies this user among all active users. +string + +4io.k8s.api.authorization.v1.LocalSubjectAccessReview "LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +A#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewSpec"Spec holds information about the request being evaluated. spec.namespace must be equal to the namespace you made the request against. If empty, it is defaulted. + +status +C#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewStatus"UStatus is filled in by the server and indicates whether the request is allowed or notr +x-kubernetes-group-version-kindOM- group: authorization.k8s.io + kind: LocalSubjectAccessReview + version: v1 + + +1io.k8s.api.authorization.v1.NonResourceAttributes"{NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface +objecto +8 +path0"#Path is the URL path of the request +string +3 +verb+"Verb is the standard HTTP verb +string + ++io.k8s.api.authorization.v1.NonResourceRule"LNonResourceRule holds information that describes a rule for the non-resourceverbs +object + +nonResourceURLs"NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. "*" means all. +array +  +string + +verbs"xVerb is a list of kubernetes non-resource API verbs, like: get, post, put, delete, patch, head, options. "*" means all. +array +  +string + +.io.k8s.api.authorization.v1.ResourceAttributes"tResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface +object +M +groupD"7Group is the API Group of the Resource. "*" means all. +string + +namez"mName is the name of the resource being requested for a "get" or deleted for a "delete". "" (empty) means all. +string + + namespace"Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces "" (empty) is defaulted for LocalSubjectAccessReviews "" (empty) is empty for cluster-scoped resources "" (empty) means "all" for namespace scoped resources from a SubjectAccessReview or SelfSubjectAccessReview +string +X +resourceL"?Resource is one of the existing resource types. "*" means all. +string +^ + subresourceO"BSubresource is one of the existing resource types. "" means none. +string + +verb{"nVerb is a kubernetes resource API verb, like: get, list, watch, create, update, delete, proxy. "*" means all. +string +S +versionH";Version is the API Version of the Resource. "*" means all. +string + +(io.k8s.api.authorization.v1.ResourceRule"ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete.verbs +object + + apiGroups"APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. "*" means all. +array +  +string + + resourceNames"ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. "*" means all. +array +  +string + + resources"Resources is a list of resources this rule applies to. "*" means all in the specified apiGroups. + "*/foo" represents the subresource 'foo' for all resources in the specified apiGroups. +array +  +string + +verbs"wVerb is a list of kubernetes resource API verbs, like: get, list, watch, create, update, delete, proxy. "*" means all. +array +  +string + +3io.k8s.api.authorization.v1.SelfSubjectAccessReview "SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means "in all namespaces". Self is a special case, because users should always be able to check whether they can perform an actionspec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +E#/definitions/io.k8s.api.authorization.v1.SelfSubjectAccessReviewSpec"XSpec holds information about the request being evaluated. user and groups must be empty + +status +C#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewStatus"UStatus is filled in by the server and indicates whether the request is allowed or notq +x-kubernetes-group-version-kindNL- group: authorization.k8s.io + kind: SelfSubjectAccessReview + version: v1 + + +7io.k8s.api.authorization.v1.SelfSubjectAccessReviewSpec"SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set +object + +nonResourceAttributes +?#/definitions/io.k8s.api.authorization.v1.NonResourceAttributes"MNonResourceAttributes describes information for a non-resource access request + +resourceAttributes +<#/definitions/io.k8s.api.authorization.v1.ResourceAttributes"SResourceAuthorizationAttributes describes information for a resource access request + +2io.k8s.api.authorization.v1.SelfSubjectRulesReview"SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server's authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +D#/definitions/io.k8s.api.authorization.v1.SelfSubjectRulesReviewSpec"9Spec holds information about the request being evaluated. + +status +B#/definitions/io.k8s.api.authorization.v1.SubjectRulesReviewStatus"VStatus is filled in by the server and indicates the set of actions a user can perform.p +x-kubernetes-group-version-kindMK- group: authorization.k8s.io + kind: SelfSubjectRulesReview + version: v1 + + +6io.k8s.api.authorization.v1.SelfSubjectRulesReviewSpec"PSelfSubjectRulesReviewSpec defines the specification for SelfSubjectRulesReview. +objectF +D + namespace7"*Namespace to evaluate rules for. Required. +string + +/io.k8s.api.authorization.v1.SubjectAccessReview +"PSubjectAccessReview checks whether or not a user or group can perform an action.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec} +A#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewSpec"8Spec holds information about the request being evaluated + +status +C#/definitions/io.k8s.api.authorization.v1.SubjectAccessReviewStatus"UStatus is filled in by the server and indicates whether the request is allowed or notm +x-kubernetes-group-version-kindJH- group: authorization.k8s.io + kind: SubjectAccessReview + version: v1 + + +3io.k8s.api.authorization.v1.SubjectAccessReviewSpec"SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set +object + +extra"Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. + +array +  +string +object +N +groupsD"(Groups is the groups you're testing for. +array +  +string + +nonResourceAttributes +?#/definitions/io.k8s.api.authorization.v1.NonResourceAttributes"MNonResourceAttributes describes information for a non-resource access request + +resourceAttributes +<#/definitions/io.k8s.api.authorization.v1.ResourceAttributes"SResourceAuthorizationAttributes describes information for a resource access request +> +uid7"*UID information about the requesting user. +string + +user"User is the user you're testing for. If you specify "User" but not "Groups", then is it interpreted as "What if User were not a member of any groups +string + +5io.k8s.api.authorization.v1.SubjectAccessReviewStatus"SubjectAccessReviewStatusallowed +object +c +allowedX"JAllowed is required. True if the action would be allowed, false otherwise. +boolean + +denied"Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. +boolean + +evaluationError"EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. +string +] +reasonS"FReason is optional. It indicates why a request was allowed or denied. +string + +4io.k8s.api.authorization.v1.SubjectRulesReviewStatus "SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it's safe to assume the subject has that permission, even if that list is incomplete. resourceRulesnonResourceRules +incomplete +object + +evaluationError"EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn't support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. +string + + +incomplete"Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation. +boolean + +nonResourceRules"NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. +array= +; +9#/definitions/io.k8s.api.authorization.v1.NonResourceRule + + resourceRules"ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn't significant, may contain duplicates, and possibly be incomplete. +array: +8 +6#/definitions/io.k8s.api.authorization.v1.ResourceRule + +5io.k8s.api.autoscaling.v1.CrossVersionObjectReference"bCrossVersionObjectReference contains enough information to let you identify the referred resource.kindname +object +6 + +apiVersion("API version of the referent +string + +kind"Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" +string +l +named"WName of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names +string" +x-kubernetes-map-type atomic + + +1io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler +"-configuration of a horizontal pod autoscaler. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +C#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec"behaviour of autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. +| +statusr +E#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus")current information about the autoscaler.h +x-kubernetes-group-version-kindEC- group: autoscaling + kind: HorizontalPodAutoscaler + version: v1 + + +5io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerList"*list of horizontal pod autoscaler objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items|"*list of horizontal pod autoscaler objects. +arrayC +A +?#/definitions/io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +b +metadataV +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata.l +x-kubernetes-group-version-kindIG- group: autoscaling + kind: HorizontalPodAutoscalerList + version: v1 + + +5io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec"-specification of a horizontal pod autoscaler.scaleTargetRef maxReplicas +object + + maxReplicas~int32"iupper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. +integer + + minReplicasint32"minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. minReplicas is allowed to be 0 if the alpha feature gate HPAScaleToZero is enabled and at least one Object or External metric is configured. Scaling is active as long as at least one metric value is available. +integer + +scaleTargetRef +C#/definitions/io.k8s.api.autoscaling.v1.CrossVersionObjectReference"reference to scaled resource; horizontal pod autoscaler will learn the current resource consumption and will set the desired number of pods by using its Scale subresource. + +targetCPUUtilizationPercentageint32"target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used. +integer + +7io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus"-current status of a horizontal pod autoscalercurrentReplicasdesiredReplicas +object + +currentCPUUtilizationPercentageint32"current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU. +integer +f +currentReplicasSint32">current number of replicas of pods managed by this autoscaler. +integer +f +desiredReplicasSint32">desired number of replicas of pods managed by this autoscaler. +integer + + lastScaleTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"last time the HorizontalPodAutoscaler scaled the number of pods; used by the autoscaler to control how often the number of pods is changed. +^ +observedGenerationHint64"3most recent generation observed by this autoscaler. +integer + +io.k8s.api.autoscaling.v1.Scale "2Scale represents a scaling request for a resource. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata. + +spec +1#/definitions/io.k8s.api.autoscaling.v1.ScaleSpec"defines the behavior of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + +status +3#/definitions/io.k8s.api.autoscaling.v1.ScaleStatus"current status of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. Read-only.V +x-kubernetes-group-version-kind31- group: autoscaling + kind: Scale + version: v1 + + +#io.k8s.api.autoscaling.v1.ScaleSpec":ScaleSpec describes the attributes of a scale subresource. +objectU +S +replicasGint32"2desired number of instances for the scaled object. +integer + +%io.k8s.api.autoscaling.v1.ScaleStatus"AScaleStatus represents the current status of a scale subresource.replicas +object +Z +replicasNint32"9actual number of observed instances of the scaled object. +integer + +selector"label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors +string + + +"io.k8s.api.autoscaling.v1.Scale_v2 +"2Scale represents a scaling request for a resource. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata. + +spec +1#/definitions/io.k8s.api.autoscaling.v1.ScaleSpec"defines the behavior of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + +status +3#/definitions/io.k8s.api.autoscaling.v1.ScaleStatus"current status of the scale. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. Read-only. + +7io.k8s.api.autoscaling.v2.ContainerResourceMetricSource"ContainerResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set.nametarget container +object +b + containerU"Hcontainer is the name of the container in the pods of the scaling target +string +B +name:"-name is the name of the resource in question. +string +x +targetn +4#/definitions/io.k8s.api.autoscaling.v2.MetricTarget"6target specifies the target value for the given metric + +7io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus"ContainerResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source.namecurrent container +object +b + containerU"HContainer is the name of the container in the pods of the scaling target +string + +currentt +9#/definitions/io.k8s.api.autoscaling.v2.MetricValueStatus"7current contains the current value for the given metric +B +name:"-Name is the name of the resource in question. +string + +5io.k8s.api.autoscaling.v2.CrossVersionObjectReference"bCrossVersionObjectReference contains enough information to let you identify the referred resource.kindname +object +6 + +apiVersion("API version of the referent +string + +kind"Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" +string +l +named"WName of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + +.io.k8s.api.autoscaling.v2.ExternalMetricSource"ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).metrictarget +object +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector +x +targetn +4#/definitions/io.k8s.api.autoscaling.v2.MetricTarget"6target specifies the target value for the given metric + +.io.k8s.api.autoscaling.v2.ExternalMetricStatus"nExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.metriccurrent +object + +currentt +9#/definitions/io.k8s.api.autoscaling.v2.MetricValueStatus"7current contains the current value for the given metric +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector + +*io.k8s.api.autoscaling.v2.HPAScalingPolicy"WHPAScalingPolicy is a single policy which must hold true for a specified past interval.typevalue periodSeconds +object + + periodSecondsint32"PeriodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). +integer +@ +type8"+Type is used to specify the scaling policy. +string + +valuewint32"bValue contains the amount of change which is permitted by the policy. It must be greater than zero +integer + + +)io.k8s.api.autoscaling.v2.HPAScalingRules +"HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. +object + +policies"policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid +array< +: +8#/definitions/io.k8s.api.autoscaling.v2.HPAScalingPolicy# +x-kubernetes-list-type atomic + + + selectPolicyt"gselectPolicy is used to specify which policy should be used. If not set, the default value Max is used. +string + +stabilizationWindowSecondsint32"StabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long). +integer + +1io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"metadata is the standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +C#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec"spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + +status +E#/definitions/io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus"7status is the current information about the autoscaler.h +x-kubernetes-group-version-kindEC- group: autoscaling + kind: HorizontalPodAutoscaler + version: v2 + + +9io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior"HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). +object + + scaleDown +7#/definitions/io.k8s.api.autoscaling.v2.HPAScalingRules"scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). + +scaleUp +7#/definitions/io.k8s.api.autoscaling.v2.HPAScalingRules"scaleUp is scaling policy for scaling Up. If not set, the default value is the higher of: + * increase no more than 4 pods per 60 seconds + * double the number of pods per 60 seconds +No stabilization is used. + +:io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition"eHorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.typestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"YlastTransitionTime is the last time the condition transitioned from one status to another +g +message\"Omessage is a human-readable explanation containing details about the transition +string +P +reasonF"9reason is the reason for the condition's last transition. +string +S +statusI"MetricStatus describes the last-read state of a single metric.type +object + +containerResource +E#/definitions/io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus"container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +external +<#/definitions/io.k8s.api.autoscaling.v2.ExternalMetricStatus"external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). + +object +:#/definitions/io.k8s.api.autoscaling.v2.ObjectMetricStatus"tobject refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object). + +pods +8#/definitions/io.k8s.api.autoscaling.v2.PodsMetricStatus"pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. + +resource +<#/definitions/io.k8s.api.autoscaling.v2.ResourceMetricStatus"resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +type"type is the type of metric source. It will be one of "ContainerResource", "External", "Object", "Pods" or "Resource", each corresponds to a matching field in the object. Note: "ContainerResource" type is available on when the feature-gate HPAContainerMetrics is enabled +string + +&io.k8s.api.autoscaling.v2.MetricTarget"aMetricTarget defines the target value, average value, or average utilization of a specific metrictype +object + +averageUtilizationint32"averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type +integer + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"faverageValue is the target value of the average of the metric across all relevant pods (as a quantity) +c +type["Ntype represents whether the metric type is Utilization, Value, or AverageValue +string + +valuew +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"8value is the target value of the metric (as a quantity). + ++io.k8s.api.autoscaling.v2.MetricValueStatus"6MetricValueStatus holds the current value for a metric +object + +averageUtilizationint32"currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. +integer + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"gaverageValue is the current value of the average of the metric across all relevant pods (as a quantity) + +valuex +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"9value is the current value of the metric (as a quantity). + +,io.k8s.api.autoscaling.v2.ObjectMetricSource"ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).describedObjecttargetmetric +object + +describedObject +C#/definitions/io.k8s.api.autoscaling.v2.CrossVersionObjectReference"SdescribedObject specifies the descriptions of a object,such as kind,name apiVersion +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector +x +targetn +4#/definitions/io.k8s.api.autoscaling.v2.MetricTarget"6target specifies the target value for the given metric + +,io.k8s.api.autoscaling.v2.ObjectMetricStatus"ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).metriccurrentdescribedObject +object + +currentt +9#/definitions/io.k8s.api.autoscaling.v2.MetricValueStatus"7current contains the current value for the given metric + +describedObject +C#/definitions/io.k8s.api.autoscaling.v2.CrossVersionObjectReference"SDescribedObject specifies the descriptions of a object,such as kind,name apiVersion +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector + +*io.k8s.api.autoscaling.v2.PodsMetricSource"PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.metrictarget +object +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector +x +targetn +4#/definitions/io.k8s.api.autoscaling.v2.MetricTarget"6target specifies the target value for the given metric + +*io.k8s.api.autoscaling.v2.PodsMetricStatus"PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).metriccurrent +object + +currentt +9#/definitions/io.k8s.api.autoscaling.v2.MetricValueStatus"7current contains the current value for the given metric +~ +metrict +8#/definitions/io.k8s.api.autoscaling.v2.MetricIdentifier"8metric identifies the target metric by name and selector + +.io.k8s.api.autoscaling.v2.ResourceMetricSource"ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set.nametarget +object +B +name:"-name is the name of the resource in question. +string +x +targetn +4#/definitions/io.k8s.api.autoscaling.v2.MetricTarget"6target specifies the target value for the given metric + +.io.k8s.api.autoscaling.v2.ResourceMetricStatus"ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source.namecurrent +object + +currentt +9#/definitions/io.k8s.api.autoscaling.v2.MetricValueStatus"7current contains the current value for the given metric +B +name:"-Name is the name of the resource in question. +string + +"1metricName is the name of the metric in question. +string + +metricSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"PmetricSelector is used to identify a specific time series within a given metric. + +targetAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"utargetAverageValue is the target per-pod value of global metric (as a quantity). Mutually exclusive with TargetValue. + + targetValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"jtargetValue is the target value of the metric (as a quantity). Mutually exclusive with TargetAverageValue. + +3io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus"nExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. +metricName currentValue +object + +currentAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"QcurrentAverageValue is the current value of metric averaged over autoscaled pods. + + currentValue~ +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"?currentValue is the current value of the metric (as a quantity) +d + +metricNameV"ImetricName is the name of a metric used for autoscaling in metric system. +string + +metricSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"PmetricSelector is used to identify a specific time series within a given metric. + +6io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"metadata is the standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +H#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec"spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + +status +J#/definitions/io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus"7status is the current information about the autoscaler.m +x-kubernetes-group-version-kindJH- group: autoscaling + kind: HorizontalPodAutoscaler + version: v2beta1 + + +?io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition"eHorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.typestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"YlastTransitionTime is the last time the condition transitioned from one status to another +g +message\"Omessage is a human-readable explanation containing details about the transition +string +P +reasonF"9reason is the reason for the condition's last transition. +string +S +statusI"MetricStatus describes the last-read state of a single metric.type +object + +containerResource +J#/definitions/io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus"container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +external +A#/definitions/io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus"external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). + +object +?#/definitions/io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus"tobject refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object). + +pods +=#/definitions/io.k8s.api.autoscaling.v2beta1.PodsMetricStatus"pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. + +resource +A#/definitions/io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus"resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +type"type is the type of metric source. It will be one of "ContainerResource", "External", "Object", "Pods" or "Resource", each corresponds to a matching field in the object. Note: "ContainerResource" type is available on when the feature-gate HPAContainerMetrics is enabled +string + +1io.k8s.api.autoscaling.v2beta1.ObjectMetricSource"ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).target +metricName targetValue +object + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"faverageValue is the target value of the average of the metric across all relevant pods (as a quantity) +L + +metricName>"1metricName is the name of the metric in question. +string + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"selector is the string-encoded form of a standard kubernetes label selector for the given metric When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping When unset, just the metricName will be used to gather metrics. + +targetv +H#/definitions/io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference"*target is the described Kubernetes object. + + targetValue} +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity">targetValue is the target value of the metric (as a quantity). + +1io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus"ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).target +metricName currentValue +object + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"gaverageValue is the current value of the average of the metric across all relevant pods (as a quantity) + + currentValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"@currentValue is the current value of the metric (as a quantity). +L + +metricName>"1metricName is the name of the metric in question. +string + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"selector is the string-encoded form of a standard kubernetes label selector for the given metric When set in the ObjectMetricSource, it is passed as an additional parameter to the metrics server for more specific metrics scoping. When unset, just the metricName will be used to gather metrics. + +targetv +H#/definitions/io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference"*target is the described Kubernetes object. + +/io.k8s.api.autoscaling.v2beta1.PodsMetricSource"PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. +metricNametargetAverageValue +object +K + +metricName="0metricName is the name of the metric in question +string + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"selector is the string-encoded form of a standard kubernetes label selector for the given metric When set, it is passed as an additional parameter to the metrics server for more specific metrics scoping When unset, just the metricName will be used to gather metrics. + +targetAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"ltargetAverageValue is the target value of the average of the metric across all relevant pods (as a quantity) + +/io.k8s.api.autoscaling.v2beta1.PodsMetricStatus"PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). +metricNamecurrentAverageValue +object + +currentAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"ncurrentAverageValue is the current value of the average of the metric across all relevant pods (as a quantity) +K + +metricName="0metricName is the name of the metric in question +string + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"selector is the string-encoded form of a standard kubernetes label selector for the given metric When set in the PodsMetricSource, it is passed as an additional parameter to the metrics server for more specific metrics scoping. When unset, just the metricName will be used to gather metrics. + +3io.k8s.api.autoscaling.v2beta1.ResourceMetricSource"ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set.name +object +B +name:"-name is the name of the resource in question. +string + +targetAverageUtilizationint32"targetAverageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. +integer + +targetAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"targetAverageValue is the target value of the average of the resource metric across all relevant pods, as a raw value (instead of as a percentage of the request), similar to the "pods" metric source type. + +3io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus "ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source.namecurrentAverageValue +object + +currentAverageUtilizationint32"currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. It will only be present if `targetAverageValue` was set in the corresponding metric specification. +integer + +currentAverageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"currentAverageValue is the current value of the average of the resource metric across all relevant pods, as a raw value (instead of as a percentage of the request), similar to the "pods" metric source type. It will always be set, regardless of the corresponding metric specification. +B +name:"-name is the name of the resource in question. +string + +#/definitions/io.k8s.api.autoscaling.v2beta2.MetricValueStatus"7current contains the current value for the given metric +B +name:"-Name is the name of the resource in question. +string + +:io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference"bCrossVersionObjectReference contains enough information to let you identify the referred resource.kindname +object +6 + +apiVersion("API version of the referent +string + +kind"Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" +string +l +named"WName of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + +3io.k8s.api.autoscaling.v2beta2.ExternalMetricSource"ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster).metrictarget +object + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector +} +targets +9#/definitions/io.k8s.api.autoscaling.v2beta2.MetricTarget"6target specifies the target value for the given metric + +3io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus"nExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object.metriccurrent +object + +currenty +>#/definitions/io.k8s.api.autoscaling.v2beta2.MetricValueStatus"7current contains the current value for the given metric + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector + +/io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy"WHPAScalingPolicy is a single policy which must hold true for a specified past interval.typevalue periodSeconds +object + + periodSecondsint32"PeriodSeconds specifies the window of time for which the policy should hold true. PeriodSeconds must be greater than zero and less than or equal to 1800 (30 min). +integer +@ +type8"+Type is used to specify the scaling policy. +string + +valuewint32"bValue contains the amount of change which is permitted by the policy. It must be greater than zero +integer + + +.io.k8s.api.autoscaling.v2beta2.HPAScalingRules +"HPAScalingRules configures the scaling behavior for one direction. These Rules are applied after calculating DesiredReplicas from metrics for the HPA. They can limit the scaling velocity by specifying scaling policies. They can prevent flapping by specifying the stabilization window, so that the number of replicas is not set instantly, instead, the safest value from the stabilization window is chosen. +object + +policies"policies is a list of potential scaling polices which can be used during scaling. At least one policy must be specified, otherwise the HPAScalingRules will be discarded as invalid +arrayA +? +=#/definitions/io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy + + selectPolicy"sselectPolicy is used to specify which policy should be used. If not set, the default value MaxPolicySelect is used. +string + +stabilizationWindowSecondsint32"StabilizationWindowSeconds is the number of seconds for which past recommendations should be considered while scaling up or scaling down. StabilizationWindowSeconds must be greater than or equal to zero and less than or equal to 3600 (one hour). If not set, use the default values: - For scale up: 0 (i.e. no stabilization is done). - For scale down: 300 (i.e. the stabilization window is 300 seconds long). +integer + +6io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler "HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"metadata is the standard object metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +H#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec"spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. + +status +J#/definitions/io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus"7status is the current information about the autoscaler.m +x-kubernetes-group-version-kindJH- group: autoscaling + kind: HorizontalPodAutoscaler + version: v2beta2 + + +>io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior"HorizontalPodAutoscalerBehavior configures the scaling behavior of the target in both Up and Down directions (scaleUp and scaleDown fields respectively). +object + + scaleDown +<#/definitions/io.k8s.api.autoscaling.v2beta2.HPAScalingRules"scaleDown is scaling policy for scaling Down. If not set, the default value is to allow to scale down to minReplicas pods, with a 300 second stabilization window (i.e., the highest recommendation for the last 300sec is used). + +scaleUp +<#/definitions/io.k8s.api.autoscaling.v2beta2.HPAScalingRules"scaleUp is scaling policy for scaling Up. If not set, the default value is the higher of: + * increase no more than 4 pods per 60 seconds + * double the number of pods per 60 seconds +No stabilization is used. + +?io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition"eHorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point.typestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"YlastTransitionTime is the last time the condition transitioned from one status to another +g +message\"Omessage is a human-readable explanation containing details about the transition +string +P +reasonF"9reason is the reason for the condition's last transition. +string +S +statusI"MetricStatus describes the last-read state of a single metric.type +object + +containerResource +J#/definitions/io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus"container resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing a single container in each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +external +A#/definitions/io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus"external refers to a global metric that is not associated with any Kubernetes object. It allows autoscaling based on information coming from components running outside of cluster (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). + +object +?#/definitions/io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus"tobject refers to a metric describing a single kubernetes object (for example, hits-per-second on an Ingress object). + +pods +=#/definitions/io.k8s.api.autoscaling.v2beta2.PodsMetricStatus"pods refers to a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. + +resource +A#/definitions/io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus"resource refers to a resource metric (such as those specified in requests and limits) known to Kubernetes describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. + +type"type is the type of metric source. It will be one of "ContainerResource", "External", "Object", "Pods" or "Resource", each corresponds to a matching field in the object. Note: "ContainerResource" type is available on when the feature-gate HPAContainerMetrics is enabled +string + ++io.k8s.api.autoscaling.v2beta2.MetricTarget"aMetricTarget defines the target value, average value, or average utilization of a specific metrictype +object + +averageUtilizationint32"averageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. Currently only valid for Resource metric source type +integer + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"faverageValue is the target value of the average of the metric across all relevant pods (as a quantity) +c +type["Ntype represents whether the metric type is Utilization, Value, or AverageValue +string + +valuew +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"8value is the target value of the metric (as a quantity). + +0io.k8s.api.autoscaling.v2beta2.MetricValueStatus"6MetricValueStatus holds the current value for a metric +object + +averageUtilizationint32"currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. +integer + + averageValue +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"gaverageValue is the current value of the average of the metric across all relevant pods (as a quantity) + +valuex +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"9value is the current value of the metric (as a quantity). + +1io.k8s.api.autoscaling.v2beta2.ObjectMetricSource"ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).describedObjecttargetmetric +object +] +describedObjectJ +H#/definitions/io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector +} +targets +9#/definitions/io.k8s.api.autoscaling.v2beta2.MetricTarget"6target specifies the target value for the given metric + +1io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus"ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object).metriccurrentdescribedObject +object + +currenty +>#/definitions/io.k8s.api.autoscaling.v2beta2.MetricValueStatus"7current contains the current value for the given metric +] +describedObjectJ +H#/definitions/io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector + +/io.k8s.api.autoscaling.v2beta2.PodsMetricSource"PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value.metrictarget +object + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector +} +targets +9#/definitions/io.k8s.api.autoscaling.v2beta2.MetricTarget"6target specifies the target value for the given metric + +/io.k8s.api.autoscaling.v2beta2.PodsMetricStatus"PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second).metriccurrent +object + +currenty +>#/definitions/io.k8s.api.autoscaling.v2beta2.MetricValueStatus"7current contains the current value for the given metric + +metricy +=#/definitions/io.k8s.api.autoscaling.v2beta2.MetricIdentifier"8metric identifies the target metric by name and selector + +3io.k8s.api.autoscaling.v2beta2.ResourceMetricSource"ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source. Only one "target" type should be set.nametarget +object +B +name:"-name is the name of the resource in question. +string +} +targets +9#/definitions/io.k8s.api.autoscaling.v2beta2.MetricTarget"6target specifies the target value for the given metric + +3io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus"ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the "pods" source.namecurrent +object + +currenty +>#/definitions/io.k8s.api.autoscaling.v2beta2.MetricValueStatus"7current contains the current value for the given metric +B +name:"-Name is the name of the resource in question. +string + +io.k8s.api.batch.v1.CronJob ":CronJob represents the configuration of a single cron job. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +-#/definitions/io.k8s.api.batch.v1.CronJobSpec"Specification of the desired behavior of a cron job, including the schedule. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +/#/definitions/io.k8s.api.batch.v1.CronJobStatus"Current status of a cron job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusR +x-kubernetes-group-version-kind/-- group: batch + kind: CronJob + version: v1 + + +io.k8s.api.batch.v1.CronJobList")CronJobList is a collection of cron jobs.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +c +itemsZ"items is the list of CronJobs. +array- ++ +)#/definitions/io.k8s.api.batch.v1.CronJob + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataV +x-kubernetes-group-version-kind31- group: batch + kind: CronJobList + version: v1 + + +io.k8s.api.batch.v1.CronJobSpec"YCronJobSpec describes how the job execution will look like and when it will actually run.schedule jobTemplate +object + +concurrencyPolicy"Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one + +Possible enum values: + - `"Allow"` allows CronJobs to run concurrently. + - `"Forbid"` forbids concurrent runs, skipping next run if previous hasn't finished yet. + - `"Replace"` cancels currently running job and replaces it with a new one.Allow + Forbid + +Replace + +string + +failedJobsHistoryLimituint32"`The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1. +integer + + jobTemplateu +1#/definitions/io.k8s.api.batch.v1.JobTemplateSpec"@Specifies the job that will be created when executing a CronJob. +] +scheduleQ"DThe schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. +string + +startingDeadlineSecondsint64"Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. +integer + +successfulJobsHistoryLimityint32"dThe number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3. +integer + +suspend"This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. +boolean + +timeZone"The time zone for the given schedule, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. If not specified, this will rely on the time zone of the kube-controller-manager process. ALPHA: This field is in alpha and must be enabled via the `CronJobTimeZone` feature gate. +string + +!io.k8s.api.batch.v1.CronJobStatus"9CronJobStatus represents the current state of a cron job. +object + +active"-A list of pointers to currently running jobs. +array4 +2 +0#/definitions/io.k8s.api.core.v1.ObjectReference# +x-kubernetes-list-type atomic + + +lastScheduleTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"FInformation when was the last time the job was successfully scheduled. + +lastSuccessfulTime} +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"BInformation when was the last time the job successfully completed. + +io.k8s.api.batch.v1.Job "1Job represents the configuration of a single job. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +)#/definitions/io.k8s.api.batch.v1.JobSpec"Specification of the desired behavior of a job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status ++#/definitions/io.k8s.api.batch.v1.JobStatus"Current status of a job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusN +x-kubernetes-group-version-kind+)- group: batch + kind: Job + version: v1 + + + io.k8s.api.batch.v1.JobCondition".JobCondition describes current state of a job.typestatus +object +p + lastProbeTime_ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"$Last time the condition was checked. + +lastTransitionTimev +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time";Last time the condition transit from one status to another. +X +messageM"@Human readable message indicating details about last transition. +string +J +reason@"3(brief) reason for the condition's last transition. +string +L +statusB"5Status of the condition, one of True, False, Unknown. +string +? +type7"*Type of job condition, Complete or Failed. +string + +io.k8s.api.batch.v1.JobList" JobList is a collection of jobs.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +[ +itemsR"items is the list of Jobs. +array) +' +%#/definitions/io.k8s.api.batch.v1.Job + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataR +x-kubernetes-group-version-kind/-- group: batch + kind: JobList + version: v1 + +% +io.k8s.api.batch.v1.JobSpec%"7JobSpec describes how the job execution will look like.template +object$ + +activeDeadlineSecondsint64"Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again. +integer +r + backoffLimitbint32"MSpecifies the number of retries before marking this job failed. Defaults to 6 +integer + +completionMode"CompletionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`. + +`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other. + +`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `$(job-name)-$(index)-$(random-string)`, the Pod hostname takes the form `$(job-name)-$(index)`. + +More completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, which is possible during upgrades due to version skew, the controller skips updates for the Job. +string + + completionsint32"Specifies the desired number of successfully finished pods the job should be run with. Setting to nil means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ +integer + +manualSelector"manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector +boolean + + parallelismint32"Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ +integer + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"A label query over pods that should match the pod count. Normally, the system sets this field for you. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + +suspend"Suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false. +boolean + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"Describes the pod that will be created when executing a job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ + +ttlSecondsAfterFinishedint32"ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes. +integer + +io.k8s.api.batch.v1.JobStatus"0JobStatus represents the current state of a Job. +object +F +active<int32"'The number of pending and running pods. +integer + +completedIndexes"CompletedIndexes holds the completed indexes when .spec.completionMode = "Indexed" in a text format. The indexes are represented as decimal integers separated by commas. The numbers are listed in increasing order. Three or more consecutive numbers are compressed and represented by the first and last element of the series, separated by a hyphen. For example, if the completed indexes are 1, 3, 4, 5 and 7, they are represented as "1,3-5,7". +string + +completionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"Represents time when the job was completed. It is not guaranteed to be set in happens-before order across separate operations. It is represented in RFC3339 form and is in UTC. The completion time is only set when the job finishes successfully. + + +conditions"The latest available observations of an object's current state. When a Job fails, one of the conditions will have type "Failed" and status true. When a Job is suspended, one of the conditions will have type "Suspended" and status true; when the Job is resumed, the status of this condition will become false. When a Job is completed, one of the conditions will have type "Complete" and status true. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ +array2 +0 +.#/definitions/io.k8s.api.batch.v1.JobCondition# +x-kubernetes-list-type atomic +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + +M +failedCint32".The number of pods which reached phase Failed. +integer + +readyint32"The number of pods which have a Ready condition. + +This field is beta-level. The job controller populates the field when the feature gate JobReadyPods is enabled (enabled by default). +integer + + startTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"Represents time when the job controller started processing a job. When a Job is created in the suspended state, this field is not set until the first time it is resumed. This field is reset every time a Job is resumed from suspension. It is represented in RFC3339 form and is in UTC. +S + succeededFint32"1The number of pods which reached phase Succeeded. +integer + +uncountedTerminatedPods +9#/definitions/io.k8s.api.batch.v1.UncountedTerminatedPods"UncountedTerminatedPods holds the UIDs of Pods that have terminated but the job controller hasn't yet accounted for in the status counters. + +The job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status: (1) Add the pod UID to the arrays in this field. (2) Remove the pod finalizer. (3) Remove the pod UID from the arrays while increasing the corresponding + counter. + +This field is beta-level. The job controller only makes use of this field when the feature gate JobTrackingWithFinalizers is enabled (enabled by default). Old jobs might not be tracked using this field, in which case the field remains null. + +#io.k8s.api.batch.v1.JobTemplateSpec"QJobTemplateSpec describes the data a Job should have when created from a template +object + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +)#/definitions/io.k8s.api.batch.v1.JobSpec"Specification of the desired behavior of the job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + ++io.k8s.api.batch.v1.UncountedTerminatedPods"rUncountedTerminatedPods holds UIDs of Pods that have terminated but haven't been accounted in Job status counters. +object +j +failed`"!Failed holds UIDs of failed Pods. +array +  +string +x-kubernetes-list-typeset + +s + succeededf"'Succeeded holds UIDs of succeeded Pods. +array +  +string +x-kubernetes-list-typeset + + + io.k8s.api.batch.v1beta1.CronJob ":CronJob represents the configuration of a single cron job. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +2#/definitions/io.k8s.api.batch.v1beta1.CronJobSpec"Specification of the desired behavior of a cron job, including the schedule. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +4#/definitions/io.k8s.api.batch.v1beta1.CronJobStatus"Current status of a cron job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusW +x-kubernetes-group-version-kind42- group: batch + kind: CronJob + version: v1beta1 + + +$io.k8s.api.batch.v1beta1.CronJobList")CronJobList is a collection of cron jobs.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +h +items_"items is the list of CronJobs. +array2 +0 +.#/definitions/io.k8s.api.batch.v1beta1.CronJob + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata[ +x-kubernetes-group-version-kind86- group: batch + kind: CronJobList + version: v1beta1 + + +$io.k8s.api.batch.v1beta1.CronJobSpec "YCronJobSpec describes how the job execution will look like and when it will actually run.schedule jobTemplate +object + +concurrencyPolicy"Specifies how to treat concurrent executions of a Job. Valid values are: - "Allow" (default): allows CronJobs to run concurrently; - "Forbid": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - "Replace": cancels currently running job and replaces it with a new one +string + +failedJobsHistoryLimitint32"The number of failed finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. +integer + + jobTemplatez +6#/definitions/io.k8s.api.batch.v1beta1.JobTemplateSpec"@Specifies the job that will be created when executing a CronJob. +] +scheduleQ"DThe schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. +string + +startingDeadlineSecondsint64"Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. +integer + +successfulJobsHistoryLimitint32"The number of successful finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 3. +integer + +suspend"This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. +boolean + +timeZone"The time zone for the given schedule, see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. If not specified, this will rely on the time zone of the kube-controller-manager process. ALPHA: This field is in alpha and must be enabled via the `CronJobTimeZone` feature gate. +string + +&io.k8s.api.batch.v1beta1.CronJobStatus"9CronJobStatus represents the current state of a cron job. +object + +active"-A list of pointers to currently running jobs. +array4 +2 +0#/definitions/io.k8s.api.core.v1.ObjectReference# +x-kubernetes-list-type atomic + + +lastScheduleTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"FInformation when was the last time the job was successfully scheduled. + +lastSuccessfulTime} +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"BInformation when was the last time the job successfully completed. + +(io.k8s.api.batch.v1beta1.JobTemplateSpec"QJobTemplateSpec describes the data a Job should have when created from a template +object + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +)#/definitions/io.k8s.api.batch.v1.JobSpec"Specification of the desired behavior of the job. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +4io.k8s.api.certificates.v1.CertificateSigningRequest"CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued. + +Kubelets use this API to obtain: + 1. client certificates to authenticate to kube-apiserver (with the "kubernetes.io/kube-apiserver-client-kubelet" signerName). + 2. serving certificates for TLS endpoints kube-apiserver can connect to securely (with the "kubernetes.io/kubelet-serving" signerName). + +This API can be used to request client certificates to authenticate to kube-apiserver (with the "kubernetes.io/kube-apiserver-client" signerName), or to obtain certificates from custom non-Kubernetes signers.spec +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +K +metadata? +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + +spec +F#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestSpec"spec contains the certificate request, and is immutable after creation. Only the request, signerName, expirationSeconds, and usages fields can be set on creation. Other fields are derived by Kubernetes and cannot be modified by users. + +status +H#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestStatus"status contains information about whether the request is approved or denied, and the certificate issued by the signer, or the failure condition indicating signer failure.r +x-kubernetes-group-version-kindOM- group: certificates.k8s.io + kind: CertificateSigningRequest + version: v1 + + +=io.k8s.api.certificates.v1.CertificateSigningRequestCondition "^CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest objecttypestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"lastTransitionTime is the time the condition last transitioned from one status to another. If unset, when a new condition type is added or an existing condition's status is changed, the server defaults this to the current time. + +lastUpdateTimez +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"?lastUpdateTime is the time of the last update to this condition +f +message["Nmessage contains a human readable message with details about the request state +string +L +reasonB"5reason indicates a brief reason for the request state +string + +status"~status of the condition, one of True, False, Unknown. Approved, Denied, and Failed conditions may not be "False" or "Unknown". +string + +type"type of the condition. Known conditions are "Approved", "Denied", and "Failed". + +An "Approved" condition is added via the /approval subresource, indicating the request was approved and should be issued by the signer. + +A "Denied" condition is added via the /approval subresource, indicating the request was denied and should not be issued by the signer. + +A "Failed" condition is added via the /status subresource, indicating the signer failed to issue the certificate. + +Approved and Denied conditions are mutually exclusive. Approved, Denied, and Failed conditions cannot be removed once added. + +Only one condition of a given type is allowed. +string + +8io.k8s.api.certificates.v1.CertificateSigningRequestList"RCertificateSigningRequestList is a collection of CertificateSigningRequest objectsitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items":items is a collection of CertificateSigningRequest objects +arrayF +D +B#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequest + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +I +metadata= +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMetav +x-kubernetes-group-version-kindSQ- group: certificates.k8s.io + kind: CertificateSigningRequestList + version: v1 + +& +8io.k8s.api.certificates.v1.CertificateSigningRequestSpec%"?CertificateSigningRequestSpec contains the certificate request.request +signerName +object$ + +expirationSecondsint32"expirationSeconds is the requested duration of validity of the issued certificate. The certificate signer may issue a certificate with a different validity duration so a client must check the delta between the notBefore and and notAfter fields in the issued certificate to determine the actual duration. + +The v1.22+ in-tree implementations of the well-known Kubernetes signers will honor this field as long as the requested duration is not greater than the maximum duration they will honor per the --cluster-signing-duration CLI flag to the Kubernetes controller manager. + +Certificate signers may not honor this field for various reasons: + + 1. Old signer that is unaware of the field (such as the in-tree + implementations prior to v1.22) + 2. Signer whose configured maximum is shorter than the requested duration + 3. Signer whose configured minimum is longer than the requested duration + +The minimum valid value for expirationSeconds is 600, i.e. 10 minutes. +integer + +extra"extra contains extra attributes of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable. + +array +  +string +object + +groups"groups contains group membership of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable. +array +  +string# +x-kubernetes-list-type atomic + + +requestbyte"request contains an x509 certificate signing request encoded in a "CERTIFICATE REQUEST" PEM block. When serialized as JSON or YAML, the data is additionally base64-encoded. +string# +x-kubernetes-list-type atomic + + + +signerName"signerName indicates the requested signer, and is a qualified name. + +List/watch requests for CertificateSigningRequests can filter on this field using a "spec.signerName=NAME" fieldSelector. + +Well-known Kubernetes signers are: + 1. "kubernetes.io/kube-apiserver-client": issues client certificates that can be used to authenticate to kube-apiserver. + Requests for this signer are never auto-approved by kube-controller-manager, can be issued by the "csrsigning" controller in kube-controller-manager. + 2. "kubernetes.io/kube-apiserver-client-kubelet": issues client certificates that kubelets use to authenticate to kube-apiserver. + Requests for this signer can be auto-approved by the "csrapproving" controller in kube-controller-manager, and can be issued by the "csrsigning" controller in kube-controller-manager. + 3. "kubernetes.io/kubelet-serving" issues serving certificates that kubelets use to serve TLS endpoints, which kube-apiserver can connect to securely. + Requests for this signer are never auto-approved by kube-controller-manager, and can be issued by the "csrsigning" controller in kube-controller-manager. + +More details are available at https://k8s.io/docs/reference/access-authn-authz/certificate-signing-requests/#kubernetes-signers + +Custom signerNames can also be specified. The signer defines: + 1. Trust distribution: how trust (CA bundles) are distributed. + 2. Permitted subjects: and behavior when a disallowed subject is requested. + 3. Required, permitted, or forbidden x509 extensions in the request (including whether subjectAltNames are allowed, which types, restrictions on allowed values) and behavior when a disallowed extension is requested. + 4. Required, permitted, or forbidden key usages / extended key usages. + 5. Expiration/certificate lifetime: whether it is fixed by the signer, configurable by the admin. + 6. Whether or not requests for CA certificates are allowed. +string + +uid"uid contains the uid of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable. +string + +usages"usages specifies a set of key usages requested in the issued certificate. + +Requests for TLS client certificates typically request: "digital signature", "key encipherment", "client auth". + +Requests for TLS serving certificates typically request: "key encipherment", "digital signature", "server auth". + +Valid values are: + "signing", "digital signature", "content commitment", + "key encipherment", "key agreement", "data encipherment", + "cert sign", "crl sign", "encipher only", "decipher only", "any", + "server auth", "client auth", + "code signing", "email protection", "s/mime", + "ipsec end system", "ipsec tunnel", "ipsec user", + "timestamping", "ocsp signing", "microsoft sgc", "netscape sgc" +array +  +string# +x-kubernetes-list-type atomic + + +username"username contains the name of the user that created the CertificateSigningRequest. Populated by the API server on creation and immutable. +string + +:io.k8s.api.certificates.v1.CertificateSigningRequestStatus"CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate. +object + + certificate +byte" +certificate is populated with an issued certificate by the signer after an Approved condition is present. This field is set via the /status subresource. Once populated, this field is immutable. + +If the certificate signing request is denied, a condition of type "Denied" is added and this field remains empty. If the signer cannot issue the certificate, a condition of type "Failed" is added and this field remains empty. + +Validation requirements: + 1. certificate must contain one or more PEM blocks. + 2. All PEM blocks must have the "CERTIFICATE" label, contain no headers, and the encoded data + must be a BER-encoded ASN.1 Certificate structure as described in section 4 of RFC5280. + 3. Non-PEM content may appear before or after the "CERTIFICATE" PEM blocks and is unvalidated, + to allow for explanatory text as described in section 5.2 of RFC7468. + +If more than one PEM block is present, and the definition of the requested spec.signerName does not indicate otherwise, the first block is the issued certificate, and subsequent blocks should be treated as intermediate certificates and presented in TLS handshakes. + +The certificate is encoded in PEM format. + +When serialized as JSON or YAML, the data is additionally base64-encoded, so it consists of: + + base64( + -----BEGIN CERTIFICATE----- + ... + -----END CERTIFICATE----- + ) +string# +x-kubernetes-list-type atomic + + + +conditions"[conditions applied to the request. Known conditions are "Approved", "Denied", and "Failed". +arrayO +M +K#/definitions/io.k8s.api.certificates.v1.CertificateSigningRequestCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + + io.k8s.api.coordination.v1.Lease "Lease defines a lease concept. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"gMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +2#/definitions/io.k8s.api.coordination.v1.LeaseSpec"Specification of the Lease. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status^ +x-kubernetes-group-version-kind;9- group: coordination.k8s.io + kind: Lease + version: v1 + + +$io.k8s.api.coordination.v1.LeaseList"%LeaseList is a list of Lease objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +l +itemsc""Items is a list of schema objects. +array2 +0 +.#/definitions/io.k8s.api.coordination.v1.Lease + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatab +x-kubernetes-group-version-kind?=- group: coordination.k8s.io + kind: LeaseList + version: v1 + + +$io.k8s.api.coordination.v1.LeaseSpec"(LeaseSpec is a specification of a Lease. +object + + acquireTimez +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime":acquireTime is a time when the current lease was acquired. +e +holderIdentityS"FholderIdentity contains the identity of the holder of a current lease. +string + +leaseDurationSecondsint32"leaseDurationSeconds is a duration that candidates for a lease need to wait to force acquire it. This is measure against time of last observed RenewTime. +integer +r +leaseTransitions^int32"IleaseTransitions is the number of transitions of a lease between holders. +integer + + renewTime +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"RrenewTime is a time when the current holder of a lease has last updated the lease. + + +3io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource +"Represents a Persistent Disk resource in AWS. + +An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.volumeID +object + +fsType"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore +string + + partitionint32"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as "1". Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty). +integer + +readOnly"readOnly value true will force the readOnly setting in VolumeMounts. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore +boolean + +volumeID"volumeID is unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore +string + +io.k8s.api.core.v1.Affinity"1Affinity is a group of affinity scheduling rules. +object +v + nodeAffinityf +-#/definitions/io.k8s.api.core.v1.NodeAffinity"5Describes node affinity scheduling rules for the pod. + + podAffinity +,#/definitions/io.k8s.api.core.v1.PodAffinity"tDescribes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). + +podAntiAffinity +0#/definitions/io.k8s.api.core.v1.PodAntiAffinity"}Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). + +!io.k8s.api.core.v1.AttachedVolume"4AttachedVolume describes a volume attached to a nodename +devicePath +object +e + +devicePathW"JDevicePath represents the device path where the volume should be available +string +0 +name("Name of the attached volume +string + +(io.k8s.api.core.v1.AzureDiskVolumeSource"TAzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.diskNamediskURI +object +^ + cachingModeO"BcachingMode is the Host Caching mode: None, Read Only, Read Write. +string +R +diskNameF"9diskName is the Name of the data disk in the blob storage +string +K +diskURI@"3diskURI is the URI of data disk in the blob storage +string + +fsType"fsType is Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string + +kind"kind expected values are Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared +string + +readOnlyu"greadOnly Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + +2io.k8s.api.core.v1.AzureFilePersistentVolumeSource"WAzureFile represents an Azure File Service mount on the host and bind mount to the pod. +secretName shareName +object + +readOnlyu"greadOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +l + +secretName^"QsecretName is the name of secret that contains Azure Storage Account Name and Key +string + +secretNamespace"~secretNamespace is the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod +string +; + shareName."!shareName is the azure Share Name +string + +(io.k8s.api.core.v1.AzureFileVolumeSource"WAzureFile represents an Azure File Service mount on the host and bind mount to the pod. +secretName shareName +object + +readOnlyu"greadOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +m + +secretName_"RsecretName is the name of secret that contains Azure Storage Account Name and Key +string +; + shareName."!shareName is the azure share Name +string + +io.k8s.api.core.v1.Binding "Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead.target +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +} +targets +0#/definitions/io.k8s.api.core.v1.ObjectReference"?The target object that you want to bind to the standard object.O +x-kubernetes-group-version-kind,*- group: "" + kind: Binding + version: v1 + + +,io.k8s.api.core.v1.CSIPersistentVolumeSource"RRepresents storage that is managed by an external CSI volume driver (Beta feature)driver volumeHandle +object + +controllerExpandSecretRef +0#/definitions/io.k8s.api.core.v1.SecretReference"controllerExpandSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerExpandVolume call. This is an alpha field and requires enabling ExpandCSIVolumes feature gate. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. + +controllerPublishSecretRef +0#/definitions/io.k8s.api.core.v1.SecretReference"controllerPublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI ControllerPublishVolume and ControllerUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. +Y +driverO"Bdriver is the name of the driver to use for this volume. Required. +string + +fsTypez"mfsType to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". +string + +nodePublishSecretRef +0#/definitions/io.k8s.api.core.v1.SecretReference"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. + +nodeStageSecretRef +0#/definitions/io.k8s.api.core.v1.SecretReference"nodeStageSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodeStageVolume and NodeStageVolume and NodeUnstageVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secrets are passed. +s +readOnlyg"YreadOnly value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write). +boolean +[ +volumeAttributesG"*volumeAttributes of the volume to publish. +  +string +object + + volumeHandle"volumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required. +string + +"io.k8s.api.core.v1.CSIVolumeSource "TRepresents a source location of a volume to mount, managed by an external CSI driverdriver +object + +driver"driver is the name of the CSI driver that handles this volume. Consult with your admin for the correct name as registered in the cluster. +string + +fsType"fsType to mount. Ex. "ext4", "xfs", "ntfs". If not provided, the empty value is passed to the associated CSI driver which will determine the default filesystem to apply. +string + +nodePublishSecretRef +5#/definitions/io.k8s.api.core.v1.LocalObjectReference"nodePublishSecretRef is a reference to the secret object containing sensitive information to pass to the CSI driver to complete the CSI NodePublishVolume and NodeUnpublishVolume calls. This field is optional, and may be empty if no secret is required. If the secret object contains more than one secret, all secret references are passed. +v +readOnlyj"\readOnly specifies a read-only configuration for the volume. Defaults to false (read/write). +boolean + +volumeAttributes"volumeAttributes stores driver-specific properties that are passed to the CSI driver. Consult your driver's documentation for supported values. +  +string +object + +io.k8s.api.core.v1.Capabilities"0 && <=86400(for 1 day) if ServiceAffinity == "ClientIP". Default value is 10800(for 3 hours). +integer + +%io.k8s.api.core.v1.ComponentCondition"/Information about the condition of a component.typestatus +object +c +errorZ"MCondition error code for a component. For example, a health check error code. +string +s +messageh"[Message about the condition for a component. For example, information about a health check. +string +z +statusp"cStatus of the condition for a component. Valid values for "Healthy": "True", "False", or "Unknown". +string +N +typeF"9Type of condition for a component. Valid value: "Healthy" +string + + +"io.k8s.api.core.v1.ComponentStatus +"yComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+ +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + +conditions"%List of component conditions observed +array7 +5 +3#/definitions/io.k8s.api.core.v1.ComponentCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataW +x-kubernetes-group-version-kind42- group: "" + kind: ComponentStatus + version: v1 + + +&io.k8s.api.core.v1.ComponentStatusList "Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +l +itemsc" List of ComponentStatus objects. +array4 +2 +0#/definitions/io.k8s.api.core.v1.ComponentStatus + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds[ +x-kubernetes-group-version-kind86- group: "" + kind: ComponentStatusList + version: v1 + + +io.k8s.api.core.v1.ConfigMap"7ConfigMap holds configuration data for pods to consume. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + +binaryData"BinaryData contains the binary data. Each key must consist of alphanumeric characters, '-', '_' or '.'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet. +byte +string +object + +data"Data contains the configuration data. Each key must consist of alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process. +  +string +object + + immutable"Immutable, if set to true, ensures that data stored in the ConfigMap cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil. +boolean + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataQ +x-kubernetes-group-version-kind.,- group: "" + kind: ConfigMap + version: v1 + + +%io.k8s.api.core.v1.ConfigMapEnvSource"ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. + +The contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables. +object + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +G +optional;"-Specify whether the ConfigMap must be defined +boolean + +'io.k8s.api.core.v1.ConfigMapKeySelector"Selects a key from a ConfigMap.key +object +& +key"The key to select. +string + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +R +optionalF"8Specify whether the ConfigMap or its key must be defined +boolean" +x-kubernetes-map-type atomic + + + io.k8s.api.core.v1.ConfigMapList"CConfigMapList is a resource containing a list of ConfigMap objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +f +items]" Items is the list of ConfigMaps. +array. +, +*#/definitions/io.k8s.api.core.v1.ConfigMap + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"gMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataU +x-kubernetes-group-version-kind20- group: "" + kind: ConfigMapList + version: v1 + + +,io.k8s.api.core.v1.ConfigMapNodeConfigSource"ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration namespacenamekubeletConfigKey +object + +kubeletConfigKey"KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases. +string +p +nameh"[Name is the metadata.name of the referenced ConfigMap. This field is required in all cases. +string + + namespacer"eNamespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases. +string + +resourceVersion"ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. +string + +uid"wUID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. +string + +&io.k8s.api.core.v1.ConfigMapProjection "Adapts a ConfigMap into a projected volume. + +The contents of the target ConfigMap's Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode. +object + +items"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array. +, +*#/definitions/io.k8s.api.core.v1.KeyToPath + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +\ +optionalP"Boptional specify whether the ConfigMap or its keys must be defined +boolean + +(io.k8s.api.core.v1.ConfigMapVolumeSource "Adapts a ConfigMap into a volume. + +The contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling. +object + + + defaultModeint32"defaultMode is optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +items"items if unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array. +, +*#/definitions/io.k8s.api.core.v1.KeyToPath + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +\ +optionalP"Boptional specify whether the ConfigMap or its keys must be defined +boolean +E +io.k8s.api.core.v1.ContainerE"AA single application container that you want to run within a pod.name +objectD + +args"Arguments to the entrypoint. The container image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array+ +) +'#/definitions/io.k8s.api.core.v1.EnvVar' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + +envFrom"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array2 +0 +.#/definitions/io.k8s.api.core.v1.EnvFromSource + +image"Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images + +Possible enum values: + - `"Always"` means that kubelet always attempts to pull the latest image. Container will fail If the pull fails. + - `"IfNotPresent"` means that kubelet pulls if the image isn't present on disk. Container will fail if the image isn't present and the pull fails. + - `"Never"` means that kubelet never pulls an image, but only uses a local image. Container will fail if the image isn't present Always + IfNotPresent +Never + +string + + lifecycle +*#/definitions/io.k8s.api.core.v1.Lifecycle"lActions that the management system should take in response to container lifecycle events. Cannot be updated. + + livenessProbe +&#/definitions/io.k8s.api.core.v1.Probe"Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + +name"Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. +string + +ports"List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default "0.0.0.0" address inside a container will be accessible from the network. Cannot be updated. +array2 +0 +.#/definitions/io.k8s.api.core.v1.ContainerPort; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap +0 +x-kubernetes-patch-merge-keycontainerPort +' +x-kubernetes-patch-strategymerge + + +readinessProbe +&#/definitions/io.k8s.api.core.v1.Probe"Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + + resources +5#/definitions/io.k8s.api.core.v1.ResourceRequirements"Compute Resources required by this container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + +securityContext +0#/definitions/io.k8s.api.core.v1.SecurityContext"SecurityContext defines the security options the container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/ + + startupProbe +&#/definitions/io.k8s.api.core.v1.Probe"StartupProbe indicates that the Pod has successfully initialized. If specified, no other probes are executed until this completes successfully. If this probe fails, the Pod will be restarted, just as if the livenessProbe failed. This can be used to provide different probe parameters at the beginning of a Pod's lifecycle, when it might take a long time to load data or warm a cache, than during steady-state operation. This cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. + +Possible enum values: + - `"FallbackToLogsOnError"` will read the most recent contents of the container logs for the container status message when the container exits with an error and the terminationMessagePath has no contents. + - `"File"` is the default behavior and will set the container status message to the contents of the container's terminationMessagePath when the container exits.FallbackToLogsOnError +File + +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array1 +/ +-#/definitions/io.k8s.api.core.v1.VolumeDevice- +x-kubernetes-patch-merge-key  devicePath +' +x-kubernetes-patch-strategymerge + + + volumeMounts"HPod volumes to mount into the container's filesystem. Cannot be updated. +array0 +. +,#/definitions/io.k8s.api.core.v1.VolumeMount, +x-kubernetes-patch-merge-key  +mountPath +' +x-kubernetes-patch-strategymerge + + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string + +!io.k8s.api.core.v1.ContainerImage"Describe a container image +object + +names"{Names by which this image is known. e.g. ["k8s.gcr.io/hyperkube:v1.0.7", "dockerhub.io/google_containers/hyperkube:v1.0.7"] +array +  +string +A + sizeBytes4int64"The size of the image in bytes. +integer + + io.k8s.api.core.v1.ContainerPort">ContainerPort represents a network port in a single container. containerPort +object + + containerPortwint32"bNumber of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. +integer +A +hostIP7"*What host IP to bind the external port to. +string + +hostPortint32"Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. +integer + +name"If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +string + +protocol"Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". + +Possible enum values: + - `"SCTP"` is the SCTP protocol. + - `"TCP"` is the TCP protocol. + - `"UDP"` is the UDP protocol.SCTP +TCP +UDP + +string + +!io.k8s.api.core.v1.ContainerState"ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting. +object +f +running[ +6#/definitions/io.k8s.api.core.v1.ContainerStateRunning"!Details about a running container +o + +terminateda +9#/definitions/io.k8s.api.core.v1.ContainerStateTerminated"$Details about a terminated container +f +waiting[ +6#/definitions/io.k8s.api.core.v1.ContainerStateWaiting"!Details about a waiting container + +(io.k8s.api.core.v1.ContainerStateRunning"8ContainerStateRunning is a running state of a container. +object{ +y + startedAtl +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"1Time at which the container was last (re-)started + ++io.k8s.api.core.v1.ContainerStateTerminated">ContainerStateTerminated is a terminated state of a container.exitCode +object +R + containerIDC"6Container's ID in the format '://' +string +W +exitCodeKint32"6Exit status from the last termination of the container +integer +t + +finishedAtf +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"+Time at which the container last terminated +O +messageD"7Message regarding the last termination of the container +string +P +reasonF"9(brief) reason from the last termination of the container +string +P +signalFint32"1Signal from the last termination of the container +integer + + startedAtt +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"9Time at which previous execution of the container started + +(io.k8s.api.core.v1.ContainerStateWaiting"8ContainerStateWaiting is a waiting state of a container. +object +O +messageD"7Message regarding why the container is not yet running. +string +G +reason="0(brief) reason the container is not yet running. +string + + +"io.k8s.api.core.v1.ContainerStatus "JContainerStatus contains details for the current status of this container.nameready restartCountimageimageID +object +S + containerIDD"7Container's ID in the format '://'. +string +{ +imager"eThe image the container is running. More info: https://kubernetes.io/docs/concepts/containers/images. +string +9 +imageID."!ImageID of the container's image. +string +y + lastStatel +/#/definitions/io.k8s.api.core.v1.ContainerState"9Details about the container's last termination condition. +r +namej"]This must be a DNS_LABEL. Each container in a pod must have a unique name. Cannot be updated. +string +V +readyM"?Specifies whether the container has passed its readiness probe. +boolean +Z + restartCountJint32"5The number of times the container has been restarted. +integer + +started"Specifies whether the container has passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. Is always true when no startupProbe is defined. +boolean +l +statec +/#/definitions/io.k8s.api.core.v1.ContainerState"0Details about the container's current condition. + +!io.k8s.api.core.v1.DaemonEndpoint"CDaemonEndpoint contains information about a single Daemon endpoint.Port +objectA +? +Port7int32""Port number of the given endpoint. +integer + +(io.k8s.api.core.v1.DownwardAPIProjection"Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode. +object} +{ +itemsr")Items is a list of DownwardAPIVolume file +array: +8 +6#/definitions/io.k8s.api.core.v1.DownwardAPIVolumeFile + +(io.k8s.api.core.v1.DownwardAPIVolumeFile "XDownwardAPIVolumeFile represents information to create the file containing the pod fieldpath +object + +fieldRef +4#/definitions/io.k8s.api.core.v1.ObjectFieldSelector"aRequired: Selects a field of the pod: only annotations, labels, name and namespace are supported. + +modeint32"Optional: mode bits used to set permissions on this file, must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"Required: Path is the relative path name of the file to be created. Must not be absolute or contain the '..' path. Must be utf-8 encoded. The first item of the relative path must not start with '..' +string + +resourceFieldRef +6#/definitions/io.k8s.api.core.v1.ResourceFieldSelector"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, requests.cpu and requests.memory) are currently supported. + +*io.k8s.api.core.v1.DownwardAPIVolumeSource"DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling. +object + + defaultModeint32"Optional: mode bits to use on created files by default. Must be a Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer +} +itemst"+Items is a list of downward API volume file +array: +8 +6#/definitions/io.k8s.api.core.v1.DownwardAPIVolumeFile + +'io.k8s.api.core.v1.EmptyDirVolumeSource"uRepresents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling. +object + +medium"medium represents what type of storage medium should back this directory. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir +string + + sizeLimit +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"sizeLimit is the total amount of local storage required for this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. The default is nil which means that the limit is undefined. More info: http://kubernetes.io/docs/user-guide/volumes#emptydir + +"io.k8s.api.core.v1.EndpointAddress"']`, `metadata.annotations['']`, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs. + +resourceFieldRef +6#/definitions/io.k8s.api.core.v1.ResourceFieldSelector"Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported. +v + secretKeyReff +2#/definitions/io.k8s.api.core.v1.SecretKeySelector"0Selects a key of a secret in the pod's namespace +B +%io.k8s.api.core.v1.EphemeralContainerB"An EphemeralContainer is a temporary container that you may add to an existing Pod for user-initiated activities such as debugging. Ephemeral containers have no resource or scheduling guarantees, and they will not be restarted when they exit or when a Pod is removed or restarted. The kubelet may evict a Pod if an ephemeral container causes the Pod to exceed its resource allocation. + +To add an ephemeral container, use the ephemeralcontainers subresource of an existing Pod. Ephemeral containers may not be removed or restarted. + +This is a beta feature available on clusters that haven't disabled the EphemeralContainers feature gate.name +object= + +args"Arguments to the entrypoint. The image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +command"Entrypoint array. Not executed within a shell. The image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell +array +  +string + +env"IList of environment variables to set in the container. Cannot be updated. +array+ +) +'#/definitions/io.k8s.api.core.v1.EnvVar' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + +envFrom"List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. +array2 +0 +.#/definitions/io.k8s.api.core.v1.EnvFromSource +l +imagec"VContainer image name. More info: https://kubernetes.io/docs/concepts/containers/images +string + +imagePullPolicy"Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images + +Possible enum values: + - `"Always"` means that kubelet always attempts to pull the latest image. Container will fail If the pull fails. + - `"IfNotPresent"` means that kubelet pulls if the image isn't present on disk. Container will fail if the image isn't present and the pull fails. + - `"Never"` means that kubelet never pulls an image, but only uses a local image. Container will fail if the image isn't present Always + IfNotPresent +Never + +string +m + lifecycle` +*#/definitions/io.k8s.api.core.v1.Lifecycle"2Lifecycle is not allowed for ephemeral containers. +k + livenessProbeZ +&#/definitions/io.k8s.api.core.v1.Probe"0Probes are not allowed for ephemeral containers. + +name"Name of the ephemeral container specified as a DNS_LABEL. This name must be unique among all containers, init containers and ephemeral containers. +string + +ports"/Ports are not allowed for ephemeral containers. +array2 +0 +.#/definitions/io.k8s.api.core.v1.ContainerPort; +x-kubernetes-list-map-keys- containerPort +- protocol + +x-kubernetes-list-typemap +0 +x-kubernetes-patch-merge-keycontainerPort +' +x-kubernetes-patch-strategymerge + +l +readinessProbeZ +&#/definitions/io.k8s.api.core.v1.Probe"0Probes are not allowed for ephemeral containers. + + resources +5#/definitions/io.k8s.api.core.v1.ResourceRequirements"zResources are not allowed for ephemeral containers. Ephemeral containers use spare resources already allocated to the pod. + +securityContext +0#/definitions/io.k8s.api.core.v1.SecurityContext"Optional: SecurityContext defines the security options the ephemeral container should be run with. If set, the fields of SecurityContext override the equivalent fields of PodSecurityContext. +j + startupProbeZ +&#/definitions/io.k8s.api.core.v1.Probe"0Probes are not allowed for ephemeral containers. + +stdin"Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. +boolean + + stdinOnce"Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false +boolean + +targetContainerName"If set, the name of the container from PodSpec that this ephemeral container targets. The ephemeral container will be run in the namespaces (IPC, PID, etc) of this container. If not set then the ephemeral container uses the namespaces configured in the Pod spec. + +The container runtime must implement support for this feature. If the runtime does not support namespace targeting then the result of setting this field is undefined. +string + +terminationMessagePath"Optional: Path at which the file to which the container's termination message will be written is mounted into the container's filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. +string + +terminationMessagePolicy"Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. + +Possible enum values: + - `"FallbackToLogsOnError"` will read the most recent contents of the container logs for the container status message when the container exits with an error and the terminationMessagePath has no contents. + - `"File"` is the default behavior and will set the container status message to the contents of the container's terminationMessagePath when the container exits.FallbackToLogsOnError +File + +string + +ttyz"lWhether this container should allocate a TTY for itself, also requires 'stdin' to be true. Default is false. +boolean + + volumeDevices"GvolumeDevices is the list of block devices to be used by the container. +array1 +/ +-#/definitions/io.k8s.api.core.v1.VolumeDevice- +x-kubernetes-patch-merge-key  devicePath +' +x-kubernetes-patch-strategymerge + + + volumeMounts"Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. Cannot be updated. +array0 +. +,#/definitions/io.k8s.api.core.v1.VolumeMount, +x-kubernetes-patch-merge-key  +mountPath +' +x-kubernetes-patch-strategymerge + + + +workingDir"Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image. Cannot be updated. +string + +(io.k8s.api.core.v1.EphemeralVolumeSource "JRepresents an ephemeral volume that is handled by a normal storage driver. +object + +volumeClaimTemplate +>#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimTemplate"Will be used to create a stand-alone PVC to provision the volume. The pod in which this EphemeralVolumeSource is embedded will be the owner of the PVC, i.e. the PVC will be deleted together with the pod. The name of the PVC will be `-` where `` is the name from the `PodSpec.Volumes` array entry. Pod validation will reject the pod if the concatenated name is not valid for a PVC (for example, too long). + +An existing PVC with that name that is not owned by the pod will *not* be used for the pod to avoid using an unrelated volume by mistake. Starting the pod is then blocked until the unrelated PVC is removed. If such a pre-created PVC is meant to be used by the pod, the PVC has to updated with an owner reference to the pod once the pod exists. Normally this should not be necessary, but it may be useful when manually reconstructing a broken cluster. + +This field is read-only and no changes will be made by Kubernetes to the PVC after it has been created. + +Required, must not be nil. + +io.k8s.api.core.v1.Event"Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.metadatainvolvedObject +object +V +actionL"?What action was taken/failed regarding to the Regarding object. +string + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +J +countAint32",The number of times this event has occurred. +integer +u + eventTimeh +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"(Time when this Event was first observed. + +firstTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"XThe time at which the event was first recorded. (Time of server receipt is in TypeMeta.) +j +involvedObjectX +0#/definitions/io.k8s.api.core.v1.ObjectReference"$The object that this event is about. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + + lastTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"HThe time at which the most recent occurrence of this event was recorded. +U +messageJ"=A human-readable description of the status of this operation. +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +reason"This should be a short, machine understandable string that gives the reason for the transition into the object's current status. +string +r +relatedg +0#/definitions/io.k8s.api.core.v1.ObjectReference"3Optional secondary object for more complex actions. +p +reportingComponentZ"MName of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. +string +U +reportingInstance@"3ID of the controller instance, e.g. `kubelet-xyzf`. +string + +series +,#/definitions/io.k8s.api.core.v1.EventSeries"SData about the Event series this event represents or nil if it's a singleton Event. + +source +,#/definitions/io.k8s.api.core.v1.EventSource"TThe component reporting this event. Should be a short machine understandable string. +a +typeY"LType of this event (Normal, Warning), new types could be added in the future +stringM +x-kubernetes-group-version-kind*(- group: "" + kind: Event + version: v1 + + +io.k8s.api.core.v1.EventList"EventList is a list of events.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +P +itemsG"List of events +array* +( +&#/definitions/io.k8s.api.core.v1.Event + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsQ +x-kubernetes-group-version-kind.,- group: "" + kind: EventList + version: v1 + + +io.k8s.api.core.v1.EventSeries"qEventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. +object +` +countWint32"BNumber of occurrences in this series up to the last heartbeat time +integer +x +lastObservedTimed +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"$Time of the last occurrence observed + +io.k8s.api.core.v1.EventSource".EventSource contains information for an event. +object +F + component9",Component from which the event is generated. +string +? +host7"*Node name on which the event is generated. +string + +io.k8s.api.core.v1.ExecAction"1ExecAction describes a "run in container" action. +object + +command"Command is the command line to execute inside the container, the working directory for the command is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. +array +  +string + +!io.k8s.api.core.v1.FCVolumeSource"Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling. +object + +fsType"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string +A +lun:int32"%lun is Optional: FC target lun number +integer + +readOnly"treadOnly is Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +b + +targetWWNsT"8targetWWNs is Optional: FC target worldwide names (WWNs) +array +  +string + +wwids"wwids Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously. +array +  +string + +-io.k8s.api.core.v1.FlexPersistentVolumeSource"FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.driver +object +O +driverE"8driver is the name of the driver to use for this volume. +string + +fsType"fsType is the Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". The default filesystem depends on FlexVolume script. +string +k +options`"Coptions is Optional: this field holds extra command options if any. +  +string +object + +readOnly"treadOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + secretRef +0#/definitions/io.k8s.api.core.v1.SecretReference"secretRef is Optional: SecretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts. + +#io.k8s.api.core.v1.FlexVolumeSource"hFlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.driver +object +O +driverE"8driver is the name of the driver to use for this volume. +string + +fsType"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". The default filesystem depends on FlexVolume script. +string +k +options`"Coptions is Optional: this field holds extra command options if any. +  +string +object + +readOnly"treadOnly is Optional: defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + secretRef +5#/definitions/io.k8s.api.core.v1.LocalObjectReference"secretRef is Optional: secretRef is reference to the secret object containing sensitive information to pass to the plugin scripts. This may be empty if no secret object is specified. If the secret object contains more than one secret, all secrets are passed to the plugin scripts. + +&io.k8s.api.core.v1.FlockerVolumeSource"Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling. +object + + datasetName"{datasetName is Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated +string +r + datasetUUIDc"VdatasetUUID is the UUID of the dataset. This is unique identifier of a Flocker dataset +string + +0io.k8s.api.core.v1.GCEPersistentDiskVolumeSource "Represents a Persistent Disk resource in Google Compute Engine. + +A GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling.pdName +object + +fsType"fsType is filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +string + + partitionint32"partition is the partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as "1". Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +integer + +pdName"pdName is unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +string + +readOnly"readOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk +boolean + +io.k8s.api.core.v1.GRPCActionport +object +e +port]int32"HPort number of the gRPC service. Number must be in the range 1 to 65535. +integer + +service"Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md). + +If this is not specified, the default behavior is defined by gRPC. +string + +&io.k8s.api.core.v1.GitRepoVolumeSource"Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling. + +DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. +repository +object + + directory"directory is the target directory name. Must not contain or start with '..'. If '.' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. +string +0 + +repository""repository is the URL +string +P +revisionD"7revision is the commit hash for the specified revision. +string + +2io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. endpointspath +object + + endpoints"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +endpointsNamespace"endpointsNamespace is the namespace that contains Glusterfs endpoint. If this field is empty, the EndpointNamespace defaults to the same namespace as the bound PVC. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +path{"npath is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +readOnly"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +boolean + +(io.k8s.api.core.v1.GlusterfsVolumeSource"Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. endpointspath +object + + endpoints"endpoints is the endpoint name that details Glusterfs topology. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +path{"npath is the Glusterfs volume path. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +string + +readOnly"readOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod +boolean + + io.k8s.api.core.v1.HTTPGetAction"=HTTPGetAction describes an action based on HTTP Get requests.port +object +} +hostu"hHost name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. +string + + httpHeaders"CCustom headers to set in the request. HTTP allows repeated headers. +array/ +- ++#/definitions/io.k8s.api.core.v1.HTTPHeader +7 +path/""Path to access on the HTTP server. +string + +port +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"}Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. + +scheme"Scheme to use for connecting to the host. Defaults to HTTP. + +Possible enum values: + - `"HTTP"` means that the scheme used will be http:// + - `"HTTPS"` means that the scheme used will be https://HTTP +HTTPS + +string + +io.k8s.api.core.v1.HTTPHeader">HTTPHeader describes a custom header to be used in HTTP probesnamevalue +objectZ +* +name""The header field name +string +, +value#"The header field value +string + +io.k8s.api.core.v1.HostAlias"oHostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file. +object +L + hostnames?"#Hostnames for the above IP address. +array +  +string +5 +ip/""IP address of the host file entry. +string + +'io.k8s.api.core.v1.HostPathVolumeSource"vRepresents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.path +object + +path"path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath +string + +type|"otype for HostPath Volume Defaults to "" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath +string + +.io.k8s.api.core.v1.ISCSIPersistentVolumeSource"ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. targetPortaliqnlun +object +p +chapAuthDiscovery["MchapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication +boolean +j +chapAuthSessionW"IchapAuthSession defines whether support iSCSI Session CHAP authentication +boolean + +fsType"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi +string + + initiatorName"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. +string +7 +iqn0"#iqn is Target iSCSI Qualified Name. +string +~ +iscsiInterfacel"_iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp). +string +; +lun4int32"lun is iSCSI Target Lun number. +integer + +portals"portals is the iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +array +  +string +k +readOnly_"QreadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. +boolean + + secretRef~ +0#/definitions/io.k8s.api.core.v1.SecretReference"JsecretRef is the CHAP Secret for iSCSI target and initiator authentication + + targetPortal"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +string + +$io.k8s.api.core.v1.ISCSIVolumeSource"Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. targetPortaliqnlun +object +p +chapAuthDiscovery["MchapAuthDiscovery defines whether support iSCSI Discovery CHAP authentication +boolean +j +chapAuthSessionW"IchapAuthSession defines whether support iSCSI Session CHAP authentication +boolean + +fsType"fsType is the filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi +string + + initiatorName"initiatorName is the custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. +string +; +iqn4"'iqn is the target iSCSI Qualified Name. +string +~ +iscsiInterfacel"_iscsiInterface is the interface Name that uses an iSCSI transport. Defaults to 'default' (tcp). +string +C +lun<int32"'lun represents iSCSI Target Lun number. +integer + +portals"portals is the iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +array +  +string +k +readOnly_"QreadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. +boolean + + secretRef +5#/definitions/io.k8s.api.core.v1.LocalObjectReference"JsecretRef is the CHAP Secret for iSCSI target and initiator authentication + + targetPortal"targetPortal is iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). +string + +io.k8s.api.core.v1.KeyToPath",Maps a string key to a path within a volume.keypath +object +. +key'"key is the key to project. +string + +modeint32"mode is Optional: mode bits used to set permissions on this file. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +path"path is the relative path of the file to map the key to. May not be an absolute path. May not contain the path element '..'. May not start with the string '..'. +string + +io.k8s.api.core.v1.Lifecycle "Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted. +object + + postStart +1#/definitions/io.k8s.api.core.v1.LifecycleHandler"PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks + +preStop +1#/definitions/io.k8s.api.core.v1.LifecycleHandler"PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks + +#io.k8s.api.core.v1.LifecycleHandler"LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified. +object +Y +execQ ++#/definitions/io.k8s.api.core.v1.ExecAction""Exec specifies the action to take. +k +httpGet` +.#/definitions/io.k8s.api.core.v1.HTTPGetAction".HTTPGet specifies the http request to perform. + + tcpSocket +0#/definitions/io.k8s.api.core.v1.TCPSocketAction"Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. + +io.k8s.api.core.v1.LimitRange "OLimitRange sets resource usage limits for each kind of resource in a Namespace. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +/#/definitions/io.k8s.api.core.v1.LimitRangeSpec"Spec defines the limits enforced. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusR +x-kubernetes-group-version-kind/-- group: "" + kind: LimitRange + version: v1 + + +!io.k8s.api.core.v1.LimitRangeItem "SLimitRangeItem defines a min/max usage limit for any resource that matches on kind.type +object + +default"WDefault resource requirement limit value by resource name if resource limit is omitted.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +defaultRequest"qDefaultRequest is the default resource requirement request value by resource name if resource request is omitted.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +max"4Max usage constraints on this kind by resource name.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +maxLimitRequestRatio"MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +min"4Min usage constraints on this kind by resource name.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object +A +type9",Type of resource that this limit applies to. +string + +!io.k8s.api.core.v1.LimitRangeList "-LimitRangeList is a list of LimitRange items.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ +array/ +- ++#/definitions/io.k8s.api.core.v1.LimitRange + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsV +x-kubernetes-group-version-kind31- group: "" + kind: LimitRangeList + version: v1 + + +!io.k8s.api.core.v1.LimitRangeSpec"NLimitRangeSpec defines a min/max usage limit for resources that match on kind.limits +object + +limits"?Limits is the list of LimitRangeItem objects that are enforced. +array3 +1 +/#/definitions/io.k8s.api.core.v1.LimitRangeItem + +&io.k8s.api.core.v1.LoadBalancerIngress"LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point. +object +{ +hostnameo"bHostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers) +string +{ +ipu"hIP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers) +string + +ports"qPorts is a list of records of service ports If used, every port defined in the service should have an entry in it +array/ +- ++#/definitions/io.k8s.api.core.v1.PortStatus# +x-kubernetes-list-type atomic + + +%io.k8s.api.core.v1.LoadBalancerStatus"NodeSpec describes the attributes that a node is created with. +object + + configSource +1#/definitions/io.k8s.api.core.v1.NodeConfigSource"Deprecated: Previously used to specify the source of the node's configuration for the DynamicKubeletConfig feature. This feature is removed from Kubelets as of 1.24 and will be fully removed in 1.26. + + +externalIDx"kDeprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966 +string +Q +podCIDRF"9PodCIDR represents the pod IP range assigned to the node. +string + +podCIDRs"podCIDRs represents the IP ranges assigned to the node for usage by Pods on that node. If this field is specified, the 0th entry must match the podCIDR field. It may contain at most 1 value for each of IPv4 and IPv6. +array +  +string' +x-kubernetes-patch-strategymerge + + + +providerIDs"fID of the node assigned by the cloud provider in the format: :// +string +c +taintsY" If specified, the node's taints. +array* +( +&#/definitions/io.k8s.api.core.v1.Taint + + unschedulable"Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration +boolean + +io.k8s.api.core.v1.NodeStatus"=NodeStatus is information about the current status of a node. +object + + addresses"List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses Note: This field is declared as mergeable, but the merge key is not sufficiently unique, which can cause data corruption when it is merged. Callers should instead use a full-replacement patch. See http://pr.k8s.io/79391 for an example. +array0 +. +,#/definitions/io.k8s.api.core.v1.NodeAddress' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + + allocatable"gAllocatable represents the resources of a node that are available for scheduling. Defaults to Capacity.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +capacity"Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + + +conditions"Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/concepts/nodes/node/#condition +array2 +0 +.#/definitions/io.k8s.api.core.v1.NodeCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +config +1#/definitions/io.k8s.api.core.v1.NodeConfigStatus"QStatus of the config assigned to the node via the dynamic Kubelet config feature. +t +daemonEndpointsa +4#/definitions/io.k8s.api.core.v1.NodeDaemonEndpoints")Endpoints of daemons running on the Node. +q +imagesg"%List of container images on this node +array3 +1 +/#/definitions/io.k8s.api.core.v1.ContainerImage + +nodeInfo +/#/definitions/io.k8s.api.core.v1.NodeSystemInfo"oSet of ids/uuids to uniquely identify the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#info + +phase"NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated. + +Possible enum values: + - `"Pending"` means the node has been created/added by the system, but not configured. + - `"Running"` means the node has been configured and has Kubernetes components running. + - `"Terminated"` means the node has been removed from the cluster. +Pending + +Running +  Terminated + +string + +volumesAttachedp".List of volumes that are attached to the node. +array3 +1 +/#/definitions/io.k8s.api.core.v1.AttachedVolume +d + volumesInUseT"8List of attachable volumes in use (mounted) by the node. +array +  +string + +!io.k8s.api.core.v1.NodeSystemInfo "CNodeSystemInfo is a set of ids/uuids to uniquely identify the node. machineID +systemUUIDbootID kernelVersionosImagecontainerRuntimeVersionkubeletVersionkubeProxyVersionoperatingSystem architecture +object +B + architecture2"%The Architecture reported by the node +string +4 +bootID*"Boot ID reported by the node. +string + +containerRuntimeVersionp"cContainerRuntime Version reported by the node through runtime remote API (e.g. containerd://1.4.2). +string +n + kernelVersion]"PKernel Version reported by the node from 'uname -r' (e.g. 3.16.0-0.bpo.4-amd64). +string +H +kubeProxyVersion4"'KubeProxy Version reported by the node. +string +D +kubeletVersion2"%Kubelet Version reported by the node. +string + + machineID"MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html +string +I +operatingSystem6")The Operating System reported by the node +string +n +osImagec"VOS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)). +string + + +systemUUID"SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid +string + +&io.k8s.api.core.v1.ObjectFieldSelector"?ObjectFieldSelector selects an APIVersioned field of an object. fieldPath +object +h + +apiVersionZ"MVersion of the schema the FieldPath is written in terms of, defaults to "v1". +string +S + fieldPathF"9Path of the field to select in the specified API version. +string" +x-kubernetes-map-type atomic + + +"io.k8s.api.core.v1.ObjectReference "]ObjectReference contains enough information to let you inspect or modify the referred object. +object +7 + +apiVersion)"API version of the referent. +string + + fieldPath"If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: "spec.containers{name}" (where "name" refers to the name of the container that triggered the event) or if no container name is specified "spec.containers[2]" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object. +string + +kind"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string + + namespace"sNamespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ +string + +resourceVersion"Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string + +uidz"mUID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids +string" +x-kubernetes-map-type atomic + + +#io.k8s.api.core.v1.PersistentVolume "PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +5#/definitions/io.k8s.api.core.v1.PersistentVolumeSpec"spec defines a specification of a persistent volume owned by the cluster. Provisioned by an administrator. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumes + +status +7#/definitions/io.k8s.api.core.v1.PersistentVolumeStatus"status represents the current information/status for the persistent volume. Populated by the system. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumesX +x-kubernetes-group-version-kind53- group: "" + kind: PersistentVolume + version: v1 + + +(io.k8s.api.core.v1.PersistentVolumeClaim "NPersistentVolumeClaim is a user's request for and claim to a persistent volume +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +:#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimSpec"spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims + +status +<#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimStatus"status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims] +x-kubernetes-group-version-kind:8- group: "" + kind: PersistentVolumeClaim + version: v1 + + +1io.k8s.api.core.v1.PersistentVolumeClaimCondition"BPersistentVolumeClaimCondition contails details about state of pvctypestatus +object +~ + lastProbeTimem +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"2lastProbeTime is the time we probed the condition. + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"UlastTransitionTime is the time the condition transitioned from one status to another. +g +message\"Omessage is the human-readable message indicating details about last transition. +string + +reason"reason is a unique, this should be a short, machine understandable string that gives the reason for condition's last transition. If it reports "ResizeStarted" that means the underlying persistent volume is being resized. +string + +status  +string + +type  +string + + +,io.k8s.api.core.v1.PersistentVolumeClaimList "CPersistentVolumeClaimList is a list of PersistentVolumeClaim items.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"items is a list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims +array: +8 +6#/definitions/io.k8s.api.core.v1.PersistentVolumeClaim + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsa +x-kubernetes-group-version-kind><- group: "" + kind: PersistentVolumeClaimList + version: v1 + + +,io.k8s.api.core.v1.PersistentVolumeClaimSpec"PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes +object + + accessModes"accessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 +array +  +string + + +dataSource +:#/definitions/io.k8s.api.core.v1.TypedLocalObjectReference"dataSource field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field. + + dataSourceRef +:#/definitions/io.k8s.api.core.v1.TypedLocalObjectReference" dataSourceRef specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef + allows any non-core object, as well as PersistentVolumeClaim objects. +* While DataSource ignores disallowed values (dropping them), DataSourceRef + preserves all values, and generates an error if a disallowed value is + specified. +(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. + + resources +5#/definitions/io.k8s.api.core.v1.ResourceRequirements"resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"?selector is a label query over volumes to consider for binding. + +storageClassName"storageClassName is the name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 +string + + +volumeMode"volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. +string +j + +volumeName\"OvolumeName is the binding reference to the PersistentVolume backing this claim. +string + +.io.k8s.api.core.v1.PersistentVolumeClaimStatus"OPersistentVolumeClaimStatus is the current status of a persistent volume claim. +object + + accessModes"accessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 +array +  +string + +allocatedResources"allocatedResources is the storage resource within AllocatedResources tracks the capacity allocated to a PVC. It may be larger than the actual capacity when a volume expansion operation is requested. For storage quota, the larger value from allocatedResources and PVC.spec.resources is used. If allocatedResources is not set, PVC.spec.resources alone is used for quota calculation. If a volume expansion capacity request is lowered, allocatedResources is only lowered if there are no expansion operations in progress and if the actual volume capacity is equal or lower than the requested capacity. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +capacity"Bcapacity represents the actual resources of the underlying volume.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + + +conditions"conditions is the current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to 'ResizeStarted'. +arrayC +A +?#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +phase"phase represents the current phase of PersistentVolumeClaim. + +Possible enum values: + - `"Bound"` used for PersistentVolumeClaims that are bound + - `"Lost"` used for PersistentVolumeClaims that lost their underlying PersistentVolume. The claim was bound to a PersistentVolume and this volume does not exist any longer and all data on it was lost. + - `"Pending"` used for PersistentVolumeClaims that are not yet boundBound +Lost + +Pending + +string + + resizeStatus"resizeStatus stores status of resize operation. ResizeStatus is not set by default but when expansion is complete resizeStatus is set to empty string by resize controller or kubelet. This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature. +string + +0io.k8s.api.core.v1.PersistentVolumeClaimTemplate"sPersistentVolumeClaimTemplate is used to produce PersistentVolumeClaim objects as part of an EphemeralVolumeSource.spec +object + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"May contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation. + +spec +:#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimSpec"The specification for the PersistentVolumeClaim. The entire content is copied unchanged into the PVC that gets created from this template. The same fields as in a PersistentVolumeClaim are also valid here. + +4io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"PersistentVolumeClaimVolumeSource references the user's PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). claimName +object + + claimName"claimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims +string +b +readOnlyV"HreadOnly Will force the ReadOnly setting in VolumeMounts. Default false. +boolean + +'io.k8s.api.core.v1.PersistentVolumeList "9PersistentVolumeList is a list of PersistentVolume items.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"pitems is a list of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes +array5 +3 +1#/definitions/io.k8s.api.core.v1.PersistentVolume + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds\ +x-kubernetes-group-version-kind97- group: "" + kind: PersistentVolumeList + version: v1 + +9 +'io.k8s.api.core.v1.PersistentVolumeSpec9"APersistentVolumeSpec is the specification of a persistent volume. +object8 + + accessModes"accessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes +array +  +string + +awsElasticBlockStore +A#/definitions/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore + + azureDisk +6#/definitions/io.k8s.api.core.v1.AzureDiskVolumeSource"TazureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. + + azureFile +@#/definitions/io.k8s.api.core.v1.AzureFilePersistentVolumeSource"WazureFile represents an Azure File Service mount on the host and bind mount to the pod. + +capacity"capacity is the description of the persistent volume's resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +cephfs +=#/definitions/io.k8s.api.core.v1.CephFSPersistentVolumeSource"JcephFS represents a Ceph FS mount on the host that shares a pod's lifetime + +cinder +=#/definitions/io.k8s.api.core.v1.CinderPersistentVolumeSource"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md + +claimRef +0#/definitions/io.k8s.api.core.v1.ObjectReference"claimRef is part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim. Expected to be non-nil when bound. claim.VolumeName is the authoritative bind between PV and PVC. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding + +csi +:#/definitions/io.k8s.api.core.v1.CSIPersistentVolumeSource"Pcsi represents storage that is handled by an external CSI driver (Beta feature). + +fc +/#/definitions/io.k8s.api.core.v1.FCVolumeSource"pfc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod. + + +flexVolume +;#/definitions/io.k8s.api.core.v1.FlexPersistentVolumeSource"hflexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. + +flocker +4#/definitions/io.k8s.api.core.v1.FlockerVolumeSource"flocker represents a Flocker volume attached to a kubelet's host machine and exposed to the pod for its usage. This depends on the Flocker control service being running + +gcePersistentDisk +>#/definitions/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + + glusterfs +@#/definitions/io.k8s.api.core.v1.GlusterfsPersistentVolumeSource"glusterfs represents a Glusterfs volume that is attached to a host and exposed to the pod. Provisioned by an admin. More info: https://examples.k8s.io/volumes/glusterfs/README.md + +hostPath +5#/definitions/io.k8s.api.core.v1.HostPathVolumeSource"hostPath represents a directory on the host. Provisioned by a developer or tester. This is useful for single-node development and testing only! On-host storage is not supported in any way and WILL NOT WORK in a multi-node cluster. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath + +iscsi +<#/definitions/io.k8s.api.core.v1.ISCSIPersistentVolumeSource"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. Provisioned by an admin. +| +locals +2#/definitions/io.k8s.api.core.v1.LocalVolumeSource"=local represents directly-attached storage with node affinity + + mountOptions"mountOptions is the list of mount options, e.g. ["ro", "soft"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options +array +  +string + +nfs +0#/definitions/io.k8s.api.core.v1.NFSVolumeSource"nfs represents an NFS mount on the host. Provisioned by an admin. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs + + nodeAffinity +3#/definitions/io.k8s.api.core.v1.VolumeNodeAffinity"nodeAffinity defines constraints that limit what nodes this volume can be accessed from. This field influences the scheduling of pods that use this volume. + +persistentVolumeReclaimPolicy"persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming + +Possible enum values: + - `"Delete"` means the volume will be deleted from Kubernetes on release from its claim. The volume plugin must support Deletion. + - `"Recycle"` means the volume will be recycled back into the pool of unbound persistent volumes on release from its claim. The volume plugin must support Recycling. + - `"Retain"` means the volume will be left in its current phase (Released) for manual reclamation by the administrator. The default policy is Retain. Delete + +Recycle + Retain + +string + +photonPersistentDisk +A#/definitions/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"pphotonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine + +portworxVolume +5#/definitions/io.k8s.api.core.v1.PortworxVolumeSource"YportworxVolume represents a portworx volume attached and mounted on kubelets host machine + +quobyte +4#/definitions/io.k8s.api.core.v1.QuobyteVolumeSource"Kquobyte represents a Quobyte mount on the host that shares a pod's lifetime + +rbd +:#/definitions/io.k8s.api.core.v1.RBDPersistentVolumeSource"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md + +scaleIO +>#/definitions/io.k8s.api.core.v1.ScaleIOPersistentVolumeSource"XscaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. + +storageClassName"storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass. +string + + storageos +@#/definitions/io.k8s.api.core.v1.StorageOSPersistentVolumeSource"storageOS represents a StorageOS volume that is attached to the kubelet's host machine and mounted into the pod More info: https://examples.k8s.io/volumes/storageos/README.md + + +volumeMode"volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec. +string + + vsphereVolume +?#/definitions/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"WvsphereVolume represents a vSphere volume attached and mounted on kubelets host machine + + +)io.k8s.api.core.v1.PersistentVolumeStatus +"DPersistentVolumeStatus is the current status of a persistent volume. +object +u +messagej"]message is a human-readable message indicating details about why the volume is in this state. +string + +phase"phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase + +Possible enum values: + - `"Available"` used for PersistentVolumes that are not yet bound Available volumes are held by the binder and matched to PersistentVolumeClaims + - `"Bound"` used for PersistentVolumes that are bound + - `"Failed"` used for PersistentVolumes that failed to be correctly recycled or deleted after being released from a claim + - `"Pending"` used for PersistentVolumes that are not available + - `"Released"` used for PersistentVolumes where the bound PersistentVolumeClaim was deleted released volumes must be recycled before becoming available again this phase is used by the persistent volume claim binder to signal to another process to reclaim the resource  +Available +Bound + Failed + +Pending +  Released + +string + +reason"{reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI. +string + +3io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"8Represents a Photon Controller persistent disk resource.pdID +object + +fsType"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string +U +pdIDM"@pdID is the ID that identifies Photon Controller persistent disk +string + +io.k8s.api.core.v1.Pod "wPod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +(#/definitions/io.k8s.api.core.v1.PodSpec"Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +*#/definitions/io.k8s.api.core.v1.PodStatus"Most recently observed status of the pod. This data may not be up to date. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusK +x-kubernetes-group-version-kind(&- group: "" + kind: Pod + version: v1 + + +io.k8s.api.core.v1.PodAffinity "?Pod affinity is a group of inter pod affinity scheduling rules. +object + + +/preferredDuringSchedulingIgnoredDuringExecution"The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. +array< +: +8#/definitions/io.k8s.api.core.v1.WeightedPodAffinityTerm + +.requiredDuringSchedulingIgnoredDuringExecution"If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. +array4 +2 +0#/definitions/io.k8s.api.core.v1.PodAffinityTerm + +"io.k8s.api.core.v1.PodAffinityTerm "Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running topologyKey +object + + labelSelector} +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"9A label query over a set of resources, in this case pods. + +namespaceSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. + + +namespaces"namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". +array +  +string + + topologyKey"This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. +string + +"io.k8s.api.core.v1.PodAntiAffinity "IPod anti affinity is a group of inter pod anti affinity scheduling rules. +object + + +/preferredDuringSchedulingIgnoredDuringExecution"The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. +array< +: +8#/definitions/io.k8s.api.core.v1.WeightedPodAffinityTerm + +.requiredDuringSchedulingIgnoredDuringExecution"If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. +array4 +2 +0#/definitions/io.k8s.api.core.v1.PodAffinityTerm + +io.k8s.api.core.v1.PodCondition"DPodCondition contains details for the current condition of this pod.typestatus +object +n + lastProbeTime] +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time""Last time we probed the condition. + +lastTransitionTime{ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"@Last time the condition transitioned from one status to another. +X +messageM"@Human-readable message indicating details about last transition. +string +^ +reasonT"GUnique, one-word, CamelCase reason for the condition's last transition. +string + +status"Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions +string + +type"}Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions +string + +io.k8s.api.core.v1.PodDNSConfig"_PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. +object + + nameservers"A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. +array +  +string + +options"A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy. +array7 +5 +3#/definitions/io.k8s.api.core.v1.PodDNSConfigOption + +searches"A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed. +array +  +string + +%io.k8s.api.core.v1.PodDNSConfigOption"9PodDNSConfigOption defines DNS resolver options of a pod. +object6 + +name" Required. +string + +value  +string + +io.k8s.api.core.v1.PodIP"IP address information for entries in the (plural) PodIPs field. Each entry includes: + IP: An IP address allocated to the pod. Routable at least within the cluster. +objectK +I +ipC"6ip is an IP address (IPv4 or IPv6) assigned to the pod +string + +io.k8s.api.core.v1.PodList "PodList is a list of Pods.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"lList of pods. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +array( +& +$#/definitions/io.k8s.api.core.v1.Pod + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsO +x-kubernetes-group-version-kind,*- group: "" + kind: PodList + version: v1 + + +io.k8s.api.core.v1.PodOS")PodOS defines the OS parameters of a pod.name +object + +name"Name is the name of the operating system. The currently supported values are linux and windows. Additional value may be defined in future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration Clients should expect to handle additional values and treat unrecognized values in this field as os: null +string + +#io.k8s.api.core.v1.PodReadinessGate":PodReadinessGate contains the reference to a pod condition conditionType +objects +q + conditionType`"SConditionType refers to a condition in the pod's condition list with matching type. +string + +%io.k8s.api.core.v1.PodSecurityContext "PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. +object + +fsGroupint64"A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: + +1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR'd with rw-rw---- + +If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that this field cannot be set when spec.os.name is windows. +integer + +fsGroupChangePolicy"fsGroupChangePolicy defines behavior of changing ownership and permission of the volume before being exposed inside Pod. This field will only apply to volume types which support fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used. Note that this field cannot be set when spec.os.name is windows. +string + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions +/#/definitions/io.k8s.api.core.v1.SELinuxOptions"The SELinux context to be applied to all containers. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. Note that this field cannot be set when spec.os.name is windows. + +seccompProfile +/#/definitions/io.k8s.api.core.v1.SeccompProfile"zThe seccomp options to use by the containers in this pod. Note that this field cannot be set when spec.os.name is windows. + +supplementalGroups"A list of groups applied to the first process run in each container, in addition to the container's primary GID. If unspecified, no groups will be added to any container. Note that this field cannot be set when spec.os.name is windows. +array +int64 +integer + +sysctls"Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. Note that this field cannot be set when spec.os.name is windows. +array+ +) +'#/definitions/io.k8s.api.core.v1.Sysctl + +windowsOptions +>#/definitions/io.k8s.api.core.v1.WindowsSecurityContextOptions"The Windows specific settings applied to all containers. If unspecified, the options within a container's SecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. +i +io.k8s.api.core.v1.PodSpeci""PodSpec is a description of a pod. +containers +objecth + +activeDeadlineSecondsint64"Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer. +integer +g +affinity[ +)#/definitions/io.k8s.api.core.v1.Affinity".If specified, the pod's scheduling constraints + +automountServiceAccountTokenu"gAutomountServiceAccountToken indicates whether a service account token should be automatically mounted. +boolean + + +containers"List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated. +array. +, +*#/definitions/io.k8s.api.core.v1.Container' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + + dnsConfig +-#/definitions/io.k8s.api.core.v1.PodDNSConfig"Specifies the DNS parameters of a pod. Parameters specified here will be merged to the generated DNS configuration based on DNSPolicy. + + dnsPolicy"Set DNS policy for the pod. Defaults to "ClusterFirst". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'. + +Possible enum values: + - `"ClusterFirst"` indicates that the pod should use cluster DNS first unless hostNetwork is true, if it is available, then fall back on the default (as determined by kubelet) DNS settings. + - `"ClusterFirstWithHostNet"` indicates that the pod should use cluster DNS first, if it is available, then fall back on the default (as determined by kubelet) DNS settings. + - `"Default"` indicates that the pod should use the default (as determined by kubelet) DNS settings. + - `"None"` indicates that the pod should use empty DNS settings. DNS parameters such as nameservers and search paths should be defined via DNSConfig. ClusterFirst +ClusterFirstWithHostNet + +Default +None + +string + +enableServiceLinks"EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true. +boolean + +ephemeralContainers"List of ephemeral containers run in this pod. Ephemeral containers may be run in an existing pod to perform user-initiated actions such as debugging. This list cannot be specified when creating a pod, and it cannot be modified by updating the pod spec. In order to add an ephemeral container to an existing pod, use the pod's ephemeralcontainers subresource. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. +array7 +5 +3#/definitions/io.k8s.api.core.v1.EphemeralContainer' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + + hostAliases"HostAliases is an optional list of hosts and IPs that will be injected into the pod's hosts file if specified. This is only valid for non-hostNetwork pods. +array. +, +*#/definitions/io.k8s.api.core.v1.HostAlias% +x-kubernetes-patch-merge-keyip +' +x-kubernetes-patch-strategymerge + +R +hostIPCG"9Use the host's ipc namespace. Optional: Default to false. +boolean + + hostNetwork"Host networking requested for this pod. Use the host's network namespace. If this option is set, the ports that will be used must be specified. Default to false. +boolean +R +hostPIDG"9Use the host's pid namespace. Optional: Default to false. +boolean + +hostnamez"mSpecifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value. +string + +imagePullSecrets"ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod +array9 +7 +5#/definitions/io.k8s.api.core.v1.LocalObjectReference' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + +initContainers"List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/ +array. +, +*#/definitions/io.k8s.api.core.v1.Container' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + + +nodeName"NodeName is a request to schedule this pod onto a specific node. If it is non-empty, the scheduler simply schedules this pod onto that node, assuming that it fits resource requirements. +string + + nodeSelector"NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/ +  +string +object" +x-kubernetes-map-type atomic + + +os +&#/definitions/io.k8s.api.core.v1.PodOS" Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set. + +If the OS field is set to linux, the following fields must be unset: -securityContext.windowsOptions + +If the OS field is set to windows, following fields must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions - spec.securityContext.seccompProfile - spec.securityContext.fsGroup - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls - spec.shareProcessNamespace - spec.securityContext.runAsUser - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups - spec.containers[*].securityContext.seLinuxOptions - spec.containers[*].securityContext.seccompProfile - spec.containers[*].securityContext.capabilities - spec.containers[*].securityContext.readOnlyRootFilesystem - spec.containers[*].securityContext.privileged - spec.containers[*].securityContext.allowPrivilegeEscalation - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser - spec.containers[*].securityContext.runAsGroup This is a beta field and requires the IdentifyPodOS feature + +overhead"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. This field will be autopopulated at admission time by the RuntimeClass admission controller. If the RuntimeClass admission controller is enabled, overhead must not be set in Pod create requests. The RuntimeClass admission controller will reject Pod create requests which have the overhead already set. If RuntimeClass is configured and selected in the PodSpec, Overhead will be set to the value defined in the corresponding RuntimeClass, otherwise it will remain unset and treated as zero. More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +preemptionPolicy"PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. +string + +priorityint32"The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. +integer + +priorityClassName"If specified, indicates the pod's priority. "system-node-critical" and "system-cluster-critical" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default. +string + +readinessGates"If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to "True" More info: https://git.k8s.io/enhancements/keps/sig-network/580-pod-readiness-gates +array5 +3 +1#/definitions/io.k8s.api.core.v1.PodReadinessGate + + restartPolicy"Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy + +Possible enum values: + - `"Always"` + - `"Never"` + - `"OnFailure"` Always +Never +  +OnFailure + +string + +runtimeClassName"RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod. If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the "legacy" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class +string + + schedulerName"If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler. +string + +securityContext +3#/definitions/io.k8s.api.core.v1.PodSecurityContext"SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty. See type description for default values of each field. + +serviceAccount"sDeprecatedServiceAccount is a depreciated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead. +string + +serviceAccountName"ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ +string + +setHostnameAsFQDN"If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default). In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname). In Windows containers, this means setting the registry value of hostname for the registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters to FQDN. If a pod does not have FQDN, this has no effect. Default to false. +boolean + +shareProcessNamespace"Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false. +boolean + + subdomain"If specified, the fully qualified Pod hostname will be "...svc.". If not specified, the pod will not have a domainname at all. +string + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds. +integer +q + tolerationsb"$If specified, the pod's tolerations. +array/ +- ++#/definitions/io.k8s.api.core.v1.Toleration + +topologySpreadConstraints"TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed. +array= +; +9#/definitions/io.k8s.api.core.v1.TopologySpreadConstraintB +x-kubernetes-list-map-keys$"- topologyKey +- whenUnsatisfiable + +x-kubernetes-list-typemap +. +x-kubernetes-patch-merge-key topologyKey +' +x-kubernetes-patch-strategymerge + + +volumes"List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes +array+ +) +'#/definitions/io.k8s.api.core.v1.Volume' +x-kubernetes-patch-merge-keyname +2 +x-kubernetes-patch-strategymerge,retainKeys + +- +io.k8s.api.core.v1.PodStatus-"PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane. +object, + + +conditions"xCurrent service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions +array1 +/ +-#/definitions/io.k8s.api.core.v1.PodCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +containerStatuses"The list has one entry per container in the manifest. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status +array4 +2 +0#/definitions/io.k8s.api.core.v1.ContainerStatus + +ephemeralContainerStatuses"Status for any ephemeral containers that have run in this pod. This field is beta-level and available on clusters that haven't disabled the EphemeralContainers feature gate. +array4 +2 +0#/definitions/io.k8s.api.core.v1.ContainerStatus +g +hostIP]"PIP address of the host to which the pod is assigned. Empty if not yet scheduled. +string + +initContainerStatuses"The list has one entry per init container in the manifest. The most recent successful init container will have ready = true, the most recently started container will have startTime set. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status +array4 +2 +0#/definitions/io.k8s.api.core.v1.ContainerStatus +k +message`"SA human readable message indicating details about why the pod is in this condition. +string + +nominatedNodeName"nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled. +string + +phase"The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values: + +Pending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod. + +More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase + +Possible enum values: + - `"Failed"` means that all containers in the pod have terminated, and at least one container has terminated in a failure (exited with a non-zero exit code or was stopped by the system). + - `"Pending"` means the pod has been accepted by the system, but one or more of the containers has not been started. This includes time before being bound to a node, as well as time spent pulling images onto the host. + - `"Running"` means the pod has been bound to a node and all of the containers have been started. At least one container is still running or is in the process of being restarted. + - `"Succeeded"` means that all containers in the pod have voluntarily terminated with a container exit code of 0, and the system is not going to restart any of these containers. + - `"Unknown"` means that for some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod. Deprecated: It isn't being set since 2015 (74da3b14b0c0f658b3bb8d2def5094686d0e9095) Failed + +Pending + +Running +  +Succeeded + +Unknown + +string +x +podIPo"bIP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated. +string + +podIPs"podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet. +array* +( +&#/definitions/io.k8s.api.core.v1.PodIP% +x-kubernetes-patch-merge-keyip +' +x-kubernetes-patch-strategymerge + + +qosClass"The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://git.k8s.io/community/contributors/design-proposals/node/resource-qos.md + +Possible enum values: + - `"BestEffort"` is the BestEffort qos class. + - `"Burstable"` is the Burstable qos class. + - `"Guaranteed"` is the Guaranteed qos class.  BestEffort +  +Burstable +  Guaranteed + +string +v +reasonl"_A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted' +string + + startTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"RFC 3339 date and time at which the object was acknowledged by the Kubelet. This is before the Kubelet pulled the container image(s) for the pod. + + +io.k8s.api.core.v1.PodTemplate "IPodTemplate describes a template for creating copies of a predefined pod. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"Template defines the pods that will be created from this pod template. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusS +x-kubernetes-group-version-kind0.- group: "" + kind: PodTemplate + version: v1 + + +"io.k8s.api.core.v1.PodTemplateList"*PodTemplateList is a list of PodTemplates.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +] +itemsT"List of pod templates +array0 +. +,#/definitions/io.k8s.api.core.v1.PodTemplate + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsW +x-kubernetes-group-version-kind42- group: "" + kind: PodTemplateList + version: v1 + + +"io.k8s.api.core.v1.PodTemplateSpec"QPodTemplateSpec describes the data a pod should have when created from a template +object + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +(#/definitions/io.k8s.api.core.v1.PodSpec"Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +io.k8s.api.core.v1.PortStatusportprotocol +object + +error"Error is to record the problem with the service port The format of the error shall comply with the following rules: - built-in error values shall be specified in this file and those shall use + CamelCase names +- cloud provider specific error values must have names that comply with the + format foo.example.com/CamelCase. +string +i +portaint32"LPort is the port number of the service port of which status is recorded here +integer + +protocol"Protocol is the protocol of the service port of which status is recorded here The supported values are: "TCP", "UDP", "SCTP" + +Possible enum values: + - `"SCTP"` is the SCTP protocol. + - `"TCP"` is the TCP protocol. + - `"UDP"` is the UDP protocol.SCTP +TCP +UDP + +string + +'io.k8s.api.core.v1.PortworxVolumeSource";PortworxVolumeSource represents a Portworx volume resource.volumeID +object + +fsType"fSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs". Implicitly inferred to be "ext4" if unspecified. +string + +readOnlyu"greadOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean +G +volumeID;".volumeID uniquely identifies a Portworx volume +string + +*io.k8s.api.core.v1.PreferredSchedulingTerm"An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).weight +preference +object + + +preferencet +1#/definitions/io.k8s.api.core.v1.NodeSelectorTerm"?A node selector term, associated with the corresponding weight. +v +weightlint32"WWeight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. +integer + +io.k8s.api.core.v1.Probe"Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic. +object +Y +execQ ++#/definitions/io.k8s.api.core.v1.ExecAction""Exec specifies the action to take. + +failureThresholdint32"}Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +integer + +grpc ++#/definitions/io.k8s.api.core.v1.GRPCAction"{GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate. +k +httpGet` +.#/definitions/io.k8s.api.core.v1.HTTPGetAction".HTTPGet specifies the http request to perform. + +initialDelaySecondsint32"Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer +} + periodSecondslint32"WHow often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +integer + +successThresholdint32"Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1. +integer +t + tcpSocketg +0#/definitions/io.k8s.api.core.v1.TCPSocketAction"3TCPSocket specifies an action involving a TCP port. + +terminationGracePeriodSecondsint64"Optional duration in seconds the pod needs to terminate gracefully upon probe failure. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this value overrides the value provided by the pod spec. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate. Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset. +integer + +timeoutSecondsint32"Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +integer + +(io.k8s.api.core.v1.ProjectedVolumeSource"$Represents a projected volume source +object + + defaultModeint32"defaultMode are the mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer +x +sourcesm")sources is the list of volume projections +array5 +3 +1#/definitions/io.k8s.api.core.v1.VolumeProjection + +&io.k8s.api.core.v1.QuobyteVolumeSource"Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.registryvolume +object +G +group>"1group to map volume access to Default is no group +string + +readOnlyv"hreadOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false. +boolean + +registry"registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes +string + +tenant"tenant owning the given Quobyte volume in the Backend Used with dynamically provisioned Quobyte volumes, value is set by the plugin +string +Q +userI" +type6")Type of replication controller condition. +string + + +,io.k8s.api.core.v1.ReplicationControllerList "EReplicationControllerList is a collection of replication controllers.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"{List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller +array: +8 +6#/definitions/io.k8s.api.core.v1.ReplicationController + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsa +x-kubernetes-group-version-kind><- group: "" + kind: ReplicationControllerList + version: v1 + + +,io.k8s.api.core.v1.ReplicationControllerSpec "KReplicationControllerSpec is the specification of a replication controller. +object + + +minReadySecondsint32"Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) +integer + +replicasint32"Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller +integer + +selector"Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors +  +string +object" +x-kubernetes-map-type atomic + + +template +0#/definitions/io.k8s.api.core.v1.PodTemplateSpec"Template is the object that describes the pod that will be created if insufficient replicas are detected. This takes precedence over a TemplateRef. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template + +.io.k8s.api.core.v1.ReplicationControllerStatus"VReplicationControllerStatus represents the current status of a replication controller.replicas +object + +availableReplicas{int32"fThe number of available replicas (ready for at least minReadySeconds) for this replication controller. +integer + + +conditions"YRepresents the latest available observations of a replication controller's current state. +arrayC +A +?#/definitions/io.k8s.api.core.v1.ReplicationControllerCondition' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +fullyLabeledReplicasint32"jThe number of pods that have labels matching the labels of the pod template of the replication controller. +integer + +observedGenerationuint64"`ObservedGeneration reflects the generation of the most recently observed replication controller. +integer +c + readyReplicasRint32"=The number of ready replicas for this replication controller. +integer + +replicasint32"Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller +integer + +(io.k8s.api.core.v1.ResourceFieldSelector"ZResourceFieldSelector represents container resources (cpu, memory) and their output formatresource +object +Y + containerNameH";Container name: required for volumes, optional for env vars +string + +divisor +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"ESpecifies the output format of the exposed resources, defaults to "1" +5 +resource)"Required: resource to select +string" +x-kubernetes-map-type atomic + + + io.k8s.api.core.v1.ResourceQuota "FResourceQuota sets aggregate quota restrictions enforced per namespace +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +2#/definitions/io.k8s.api.core.v1.ResourceQuotaSpec"Spec defines the desired quota. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +4#/definitions/io.k8s.api.core.v1.ResourceQuotaStatus"Status defines the actual enforced quota and its current usage. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusU +x-kubernetes-group-version-kind20- group: "" + kind: ResourceQuota + version: v1 + + +$io.k8s.api.core.v1.ResourceQuotaList "3ResourceQuotaList is a list of ResourceQuota items.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"pItems is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ +array2 +0 +.#/definitions/io.k8s.api.core.v1.ResourceQuota + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsY +x-kubernetes-group-version-kind64- group: "" + kind: ResourceQuotaList + version: v1 + + +$io.k8s.api.core.v1.ResourceQuotaSpec"GResourceQuotaSpec defines the desired hard limits to enforce for Quota. +object + +hard"hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + + scopeSelector +.#/definitions/io.k8s.api.core.v1.ScopeSelector"scopeSelector is also a collection of filters like scopes that must match each object tracked by a quota but expressed using ScopeSelectorOperator in combination with possible values. For a resource to match, both scopes AND scopeSelector (if specified in spec), must be matched. + +scopes"xA collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects. +array +  +string + +&io.k8s.api.core.v1.ResourceQuotaStatus"FResourceQuotaStatus defines the enforced hard limits and observed use. +object + +hard"Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +used"JUsed is the current observed total usage of the resource in the namespace.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +'io.k8s.api.core.v1.ResourceRequirements"AResourceRequirements describes the compute resource requirements. +object + +limits"Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +requests"Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +!io.k8s.api.core.v1.SELinuxOptions"=0  BestEffort +CrossNamespacePodAffinity +NotBestEffort +NotTerminating +PriorityClass + Terminating + +string + +values"An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + +!io.k8s.api.core.v1.SeccompProfile "fSeccompProfile defines a pod/container's seccomp profile settings. Only one profile source may be set.type +object + +localhostProfile"localhostProfile indicates a profile defined in a file on the node should be used. The profile must be preconfigured on the node to work. Must be a descending path, relative to the kubelet's configured seccomp profile location. Must only be set if type is "Localhost". +string + +type"type indicates which kind of seccomp profile will be applied. Valid options are: + +Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the container runtime default profile should be used. Unconfined - no profile should be applied. + +Possible enum values: + - `"Localhost"` indicates a profile defined in a file on the node should be used. The file's location relative to /seccomp. + - `"RuntimeDefault"` represents the default container runtime seccomp profile. + - `"Unconfined"` indicates no seccomp profile is applied (A.K.A. unconfined).  +Localhost +RuntimeDefault +  Unconfined + +stringr +x-kubernetes-unions[Y- discriminator: type + fields-to-discriminateBy: + localhostProfile: LocalhostProfile + + +io.k8s.api.core.v1.Secret"Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +data"Data contains the secret data. Each key must consist of alphanumeric characters, '-', '_' or '.'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4 +byte +string +object + + immutable"Immutable, if set to true, ensures that data stored in the Secret cannot be updated (only object metadata can be modified). If not set to true, the field can be modified at any time. Defaulted to nil. +boolean + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + +stringData"stringData allows specifying non-binary secret data in string form. It is provided as a write-only input field for convenience. All keys and values are merged into the data field on write, overwriting any existing values. The stringData field is never output when reading from the API. +  +string +object + +type"Used to facilitate programmatic handling of secret data. More info: https://kubernetes.io/docs/concepts/configuration/secret/#secret-types +stringN +x-kubernetes-group-version-kind+)- group: "" + kind: Secret + version: v1 + + +"io.k8s.api.core.v1.SecretEnvSource"SecretEnvSource selects a Secret to populate the environment variables with. + +The contents of the target Secret's Data field will represent the key-value pairs as environment variables. +object + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +D +optional8"*Specify whether the Secret must be defined +boolean + +$io.k8s.api.core.v1.SecretKeySelector",SecretKeySelector selects a key of a Secret.key +object +V +keyO"BThe key of the secret to select from. Must be a valid secret key. +string + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +O +optionalC"5Specify whether the Secret or its key must be defined +boolean" +x-kubernetes-map-type atomic + + +io.k8s.api.core.v1.SecretList "SecretList is a list of Secret.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"fItems is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret +array+ +) +'#/definitions/io.k8s.api.core.v1.Secret + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsR +x-kubernetes-group-version-kind/-- group: "" + kind: SecretList + version: v1 + + +#io.k8s.api.core.v1.SecretProjection"Adapts a secret into a projected volume. + +The contents of the target Secret's Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode. +object + +items"items if unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array. +, +*#/definitions/io.k8s.api.core.v1.KeyToPath + +name|"oName of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string +^ +optionalR"Doptional field specify whether the Secret or its key must be defined +boolean + +"io.k8s.api.core.v1.SecretReference"lSecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace +object +V +nameN"Aname is unique within a namespace to reference a secret resource. +string +b + namespaceU"Hnamespace defines the space within which the secret name must be unique. +string" +x-kubernetes-map-type atomic + + +%io.k8s.api.core.v1.SecretVolumeSource "Adapts a Secret into a volume. + +The contents of the target Secret's Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling. +object + + + defaultModeint32"defaultMode is Optional: mode bits used to set permissions on created files by default. Must be an octal value between 0000 and 0777 or a decimal value between 0 and 511. YAML accepts both octal and decimal values, JSON requires decimal values for mode bits. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. +integer + +items"items If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the '..' path or start with '..'. +array. +, +*#/definitions/io.k8s.api.core.v1.KeyToPath +_ +optionalS"Eoptional field specify whether the Secret or its keys must be defined +boolean + + +secretName"secretName is the name of the secret in the pod's namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret +string + +"io.k8s.api.core.v1.SecurityContext"SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence. +object + +allowPrivilegeEscalation"AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note that this field cannot be set when spec.os.name is windows. +boolean + + capabilities +-#/definitions/io.k8s.api.core.v1.Capabilities"The capabilities to add/drop when running containers. Defaults to the default set of capabilities granted by the container runtime. Note that this field cannot be set when spec.os.name is windows. + + +privileged"Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. Note that this field cannot be set when spec.os.name is windows. +boolean + + procMount"procMount denotes the type of proc mount to use for the containers. The default is DefaultProcMount which uses the container runtime defaults for readonly paths and masked paths. This requires the ProcMountType feature flag to be enabled. Note that this field cannot be set when spec.os.name is windows. +string + +readOnlyRootFilesystem"Whether this container has a read-only root filesystem. Default is false. Note that this field cannot be set when spec.os.name is windows. +boolean + + +runAsGroupint64"The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + + runAsNonRoot"Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +boolean + + runAsUserint64"The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. +integer + +seLinuxOptions +/#/definitions/io.k8s.api.core.v1.SELinuxOptions"The SELinux context to be applied to the container. If unspecified, the container runtime will allocate a random SELinux context for each container. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is windows. + +seccompProfile +/#/definitions/io.k8s.api.core.v1.SeccompProfile"The seccomp options to use by this container. If seccomp options are provided at both the pod & container level, the container options override the pod options. Note that this field cannot be set when spec.os.name is windows. + +windowsOptions +>#/definitions/io.k8s.api.core.v1.WindowsSecurityContextOptions"The Windows specific settings applied to all containers. If unspecified, the options from the PodSecurityContext will be used. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. Note that this field cannot be set when spec.os.name is linux. + +io.k8s.api.core.v1.Service "Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +,#/definitions/io.k8s.api.core.v1.ServiceSpec"Spec defines the behavior of a service. https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +.#/definitions/io.k8s.api.core.v1.ServiceStatus"Most recently observed status of the service. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusO +x-kubernetes-group-version-kind,*- group: "" + kind: Service + version: v1 + + +!io.k8s.api.core.v1.ServiceAccount"ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +automountServiceAccountToken"AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level. +boolean + +imagePullSecrets"ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod +array9 +7 +5#/definitions/io.k8s.api.core.v1.LocalObjectReference + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +secrets"Secrets is a list of the secrets in the same namespace that pods running using this ServiceAccount are allowed to use. Pods are only limited to this list if this service account has a "kubernetes.io/enforce-mountable-secrets" annotation set to "true". This field should not be used to find auto-generated service account token secrets for use outside of pods. Instead, tokens can be requested directly using the TokenRequest API, or service account token secrets can be manually created. More info: https://kubernetes.io/docs/concepts/configuration/secret +array4 +2 +0#/definitions/io.k8s.api.core.v1.ObjectReference' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge +V +x-kubernetes-group-version-kind31- group: "" + kind: ServiceAccount + version: v1 + + +%io.k8s.api.core.v1.ServiceAccountList "6ServiceAccountList is a list of ServiceAccount objectsitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"wList of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ +array3 +1 +/#/definitions/io.k8s.api.core.v1.ServiceAccount + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsZ +x-kubernetes-group-version-kind75- group: "" + kind: ServiceAccountList + version: v1 + + +0io.k8s.api.core.v1.ServiceAccountTokenProjection"ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise).path +object + +audience"audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. +string + +expirationSecondsint64"expirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes. +integer +h +path`"Spath is the path relative to the mount point of the file to project the token into. +string + +io.k8s.api.core.v1.ServiceList"%ServiceList holds a list of services.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +T +itemsK"List of services +array, +* +(#/definitions/io.k8s.api.core.v1.Service + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsS +x-kubernetes-group-version-kind0.- group: "" + kind: ServiceList + version: v1 + + +io.k8s.api.core.v1.ServicePort"3ServicePort contains information on service's port.port +object + + appProtocol"The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names such as mycompany.com/my-custom-protocol. +string + +name"The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. When considering the endpoints for a Service, this must match the 'name' field in the EndpointPort. Optional if only one ServicePort is defined on this service. +string + +nodePortint32"The port on each node on which this service is exposed when type is NodePort or LoadBalancer. Usually assigned by the system. If a value is specified, in-range, and not in use it will be used, otherwise the operation will fail. If not specified, a port will be allocated if this Service requires one. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type from NodePort to ClusterIP). More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport +integer +K +portCint32".The port that will be exposed by this service. +integer + +protocol"The IP protocol for this port. Supports "TCP", "UDP", and "SCTP". Default is TCP. + +Possible enum values: + - `"SCTP"` is the SCTP protocol. + - `"TCP"` is the TCP protocol. + - `"UDP"` is the UDP protocol.SCTP +TCP +UDP + +string + + +targetPort +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"Number or name of the port to access on the pods targeted by the service. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. If this is a string, it will be looked up as a named port in the target Pod's container ports. If this is not specified, the value of the 'port' field is used (an identity map). This field is ignored for services with clusterIP=None, and should be omitted or set equal to the 'port' field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service +f +io.k8s.api.core.v1.ServiceSpecf"FServiceSpec describes the attributes that a user creates on a service. +objecte + +allocateLoadBalancerNodePorts"allocateLoadBalancerNodePorts defines if NodePorts will be automatically allocated for services with type LoadBalancer. Default is "true". It may be set to "false" if the cluster load-balancer does not rely on NodePorts. If the caller requests specific NodePorts (by specifying a value), those requests will be respected, regardless of this field. This field may only be set for services with type LoadBalancer and will be cleared if the type is changed to any other type. +boolean + + clusterIP"clusterIP is the IP address of the service and is usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be blank) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are "None", empty string (""), or a valid IP address. Setting this to "None" makes a "headless service" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies +string + + +clusterIPs " ClusterIPs is a list of IP addresses assigned to this service, and are usually assigned randomly. If an address is specified manually, is in-range (as per system configuration), and is not in use, it will be allocated to the service; otherwise creation of the service will fail. This field may not be changed through updates unless the type field is also being changed to ExternalName (which requires this field to be empty) or the type field is being changed from ExternalName (in which case this field may optionally be specified, as describe above). Valid values are "None", empty string (""), or a valid IP address. Setting this to "None" makes a "headless service" (no virtual IP), which is useful when direct endpoint connections are preferred and proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating a Service of type ExternalName, creation will fail. This field will be wiped when updating a Service to type ExternalName. If this field is not specified, it will be initialized from the clusterIP field. If this field is specified, clients must ensure that clusterIPs[0] and clusterIP have the same value. + +This field may hold a maximum of two entries (dual-stack IPs, in either order). These IPs must correspond to the values of the ipFamilies field. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies +array +  +string# +x-kubernetes-list-type atomic + + + externalIPs"externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system. +array +  +string + + externalName"externalName is the external reference that discovery mechanisms will return as an alias for this service (e.g. a DNS CNAME record). No proxying will be involved. Must be a lowercase RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires `type` to be "ExternalName". +string + +externalTrafficPolicy"externalTrafficPolicy denotes if this Service desires to route external traffic to node-local or cluster-wide endpoints. "Local" preserves the client source IP and avoids a second hop for LoadBalancer and Nodeport type services, but risks potentially imbalanced traffic spreading. "Cluster" obscures the client source IP and may cause a second hop to another node, but should have good overall load-spreading. + +Possible enum values: + - `"Cluster"` specifies node-global (legacy) behavior. + - `"Local"` specifies node-local endpoints behavior. +Cluster +Local + +string + +healthCheckNodePortint32"healthCheckNodePort specifies the healthcheck nodePort for the service. This only applies when type is set to LoadBalancer and externalTrafficPolicy is set to Local. If a value is specified, is in-range, and is not in use, it will be used. If not specified, a value will be automatically allocated. External systems (e.g. load-balancers) can use this port to determine if a given node holds endpoints for this service or not. If this field is specified when creating a Service which does not need it, creation will fail. This field will be wiped when updating a Service to no longer need it (e.g. changing type). +integer + +internalTrafficPolicy"InternalTrafficPolicy specifies if the cluster internal traffic should be routed to all endpoints or node-local endpoints only. "Cluster" routes internal traffic to a Service to all endpoints. "Local" routes traffic to node-local endpoints only, traffic is dropped if no node-local endpoints are ready. The default value is "Cluster". +string + + +ipFamilies"IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service. This field is usually assigned automatically based on cluster configuration and the ipFamilyPolicy field. If this field is specified manually, the requested family is available in the cluster, and ipFamilyPolicy allows it, it will be used; otherwise creation of the service will fail. This field is conditionally mutable: it allows for adding or removing a secondary IP family, but it does not allow changing the primary IP family of the Service. Valid values are "IPv4" and "IPv6". This field only applies to Services of types ClusterIP, NodePort, and LoadBalancer, and does apply to "headless" services. This field will be wiped when updating a Service to type ExternalName. + +This field may hold a maximum of two entries (dual-stack families, in either order). These families must correspond to the values of the clusterIPs field, if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy field. +array +  +string# +x-kubernetes-list-type atomic + + +ipFamilyPolicy"IPFamilyPolicy represents the dual-stack-ness requested or required by this Service. If there is no value provided, then this field will be set to SingleStack. Services can be "SingleStack" (a single IP family), "PreferDualStack" (two IP families on dual-stack configured clusters or a single IP family on single-stack clusters), or "RequireDualStack" (two IP families on dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs fields depend on the value of this field. This field will be wiped when updating a service to type ExternalName. +string + +loadBalancerClass"loadBalancerClass is the class of the load balancer implementation this Service belongs to. If specified, the value of this field must be a label-style identifier, with an optional prefix, e.g. "internal-vip" or "example.com/internal-vip". Unprefixed names are reserved for end-users. This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load balancer implementation is used, today this is typically done through the cloud provider integration, but should apply for any default implementation. If set, it is assumed that a load balancer implementation is watching for Services with a matching class. Any default load balancer implementation (e.g. cloud providers) should ignore Services that set this field. This field can only be set when creating or updating a Service to type 'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type. +string + +loadBalancerIP"Only applies to Service Type: LoadBalancer. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. Deprecated: This field was under-specified and its meaning varies across implementations, and it cannot support dual-stack. As of Kubernetes v1.24, users are encouraged to use implementation-specific annotations when available. This field may be removed in a future API version. +string + +loadBalancerSourceRanges"If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature." More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/ +array +  +string + +ports"The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies +array0 +. +,#/definitions/io.k8s.api.core.v1.ServicePort2 +x-kubernetes-list-map-keys- port +- protocol + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keyport +' +x-kubernetes-patch-strategymerge + + +publishNotReadyAddresses"publishNotReadyAddresses indicates that any agent which deals with endpoints for this Service should disregard any indications of ready/not-ready. The primary use case for setting this field is for a StatefulSet's Headless Service to propagate SRV DNS records for its Pods for the purpose of peer discovery. The Kubernetes controllers that generate Endpoints and EndpointSlice resources for Services interpret this to mean that all endpoints are considered "ready" even if the Pods themselves are not. Agents which consume only Kubernetes generated endpoints through the Endpoints or EndpointSlice resources can safely assume this behavior. +boolean + +selector"Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/ +  +string +object" +x-kubernetes-map-type atomic + + +sessionAffinity"Supports "ClientIP" and "None". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies + +Possible enum values: + - `"ClientIP"` is the Client IP based. + - `"None"` - no session affinity.  ClientIP +None + +string + +sessionAffinityConfig +6#/definitions/io.k8s.api.core.v1.SessionAffinityConfig"FsessionAffinityConfig contains the configurations of session affinity. + +type " type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. "ClusterIP" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is "None", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. "NodePort" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. "LoadBalancer" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. "ExternalName" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types + +Possible enum values: + - `"ClusterIP"` means a service will only be accessible inside the cluster, via the cluster IP. + - `"ExternalName"` means a service consists of only a reference to an external name that kubedns or equivalent will return as a CNAME record, with no exposing or proxying of any pods involved. + - `"LoadBalancer"` means a service will be exposed via an external load balancer (if the cloud provider supports it), in addition to 'NodePort' type. + - `"NodePort"` means a service will be exposed on one port of every node, in addition to 'ClusterIP' type.  +ClusterIP + ExternalName + LoadBalancer +  NodePort + +string + + io.k8s.api.core.v1.ServiceStatus"9ServiceStatus represents the current status of a service. +object + + +conditions"Current service state +array@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Condition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + + loadBalancer +3#/definitions/io.k8s.api.core.v1.LoadBalancerStatus"QLoadBalancer contains the current status of the load-balancer, if one is present. + +(io.k8s.api.core.v1.SessionAffinityConfig"HSessionAffinityConfig represents the configurations of session affinity. +object + +clientIP| +/#/definitions/io.k8s.api.core.v1.ClientIPConfig"IclientIP contains the configurations of Client IP based session affinity. + +2io.k8s.api.core.v1.StorageOSPersistentVolumeSource "2Represents a StorageOS persistent volume resource. +object + +fsType"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string + +readOnlyu"greadOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + secretRef +0#/definitions/io.k8s.api.core.v1.ObjectReference"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted. + + +volumeName}"pvolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. +string + +volumeNamespace"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to "default" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. +string + +(io.k8s.api.core.v1.StorageOSVolumeSource "2Represents a StorageOS persistent volume resource. +object + +fsType"fsType is the filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string + +readOnlyu"greadOnly defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. +boolean + + secretRef +5#/definitions/io.k8s.api.core.v1.LocalObjectReference"secretRef specifies the secret to use for obtaining the StorageOS API credentials. If not specified, default values will be attempted. + + +volumeName}"pvolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. +string + +volumeNamespace"volumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod's namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to "default" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. +string + +io.k8s.api.core.v1.Sysctl"+Sysctl defines a kernel parameter to be setnamevalue +objectb +. +name&"Name of a property to set +string +0 +value'"Value of a property to set +string + +"io.k8s.api.core.v1.TCPSocketAction"=TCPSocketAction describes an action based on opening a socketport +object +O +hostG":Optional: Host name to connect to, defaults to the pod IP. +string + +port +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"}Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. + + +io.k8s.api.core.v1.Taint +"`The node this Taint is attached to has the "effect" on any pod that does not tolerate the Taint.keyeffect +object + +effect"Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. + +Possible enum values: + - `"NoExecute"` Evict any already-running pods that do not tolerate the taint. Currently enforced by NodeController. + - `"NoSchedule"` Do not allow new pods to schedule onto the node unless they tolerate the taint, but allow all pods submitted to Kubelet without going through the scheduler to start, and allow all already-running pods to continue running. Enforced by the scheduler. + - `"PreferNoSchedule"` Like TaintEffectNoSchedule, but the scheduler tries not to schedule new pods onto the node, rather than prohibiting new pods from scheduling onto the node entirely. Enforced by the scheduler.  +NoExecute +  NoSchedule +PreferNoSchedule + +string +D +key="0Required. The taint key to be applied to a node. +string + + timeAdded +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"dTimeAdded represents the time at which the taint was added. It is only written for NoExecute taints. +E +value<"/The taint value corresponding to the taint key. +string + +io.k8s.api.core.v1.Toleration"The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . +object + +effect"Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. + +Possible enum values: + - `"NoExecute"` Evict any already-running pods that do not tolerate the taint. Currently enforced by NodeController. + - `"NoSchedule"` Do not allow new pods to schedule onto the node unless they tolerate the taint, but allow all pods submitted to Kubelet without going through the scheduler to start, and allow all already-running pods to continue running. Enforced by the scheduler. + - `"PreferNoSchedule"` Like TaintEffectNoSchedule, but the scheduler tries not to schedule new pods onto the node, rather than prohibiting new pods from scheduling onto the node entirely. Enforced by the scheduler.  +NoExecute +  NoSchedule +PreferNoSchedule + +string + +key"Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. +string + +operator"Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. + +Possible enum values: + - `"Equal"` + - `"Exists"`Equal + Exists + +string + +tolerationSecondsint64"TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. +integer + +value"Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. +string + +3io.k8s.api.core.v1.TopologySelectorLabelRequirement"~A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future.keyvalues +object +? +key8"+The label key that the selector applies to. +string + +values"gAn array of string values. One value must match the label to be selected. Each entry in Values is ORed. +array +  +string + +'io.k8s.api.core.v1.TopologySelectorTerm"A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future. +object + +matchLabelExpressions"3A list of topology selector requirements by labels. +arrayE +C +A#/definitions/io.k8s.api.core.v1.TopologySelectorLabelRequirement" +x-kubernetes-map-type atomic + +$ ++io.k8s.api.core.v1.TopologySpreadConstraint$"XTopologySpreadConstraint specifies how to spread matching pods among the given topology.maxSkew topologyKeywhenUnsatisfiable +object" + + labelSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"LabelSelector is used to find matching pods. Pods that match this label selector are counted to determine the number of pods in their corresponding topology domain. + +maxSkewint32"MaxSkew describes the degree to which pods may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference between the number of matching pods in the target topology and the global minimum. The global minimum is the minimum number of matching pods in an eligible domain or zero if the number of eligible domains is less than MinDomains. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 2/2/1: In this case, the global minimum is 1. | zone1 | zone2 | zone3 | | P P | P P | P | - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2; scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2) violate MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled onto any zone. When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence to topologies that satisfy it. It's a required field. Default value is 1 and 0 is not allowed. +integer + + + +minDomains +int32" MinDomains indicates a minimum number of eligible domains. When the number of eligible domains with matching topology keys is less than minDomains, Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed. And when the number of eligible domains with matching topology keys equals or greater than minDomains, this value has no effect on scheduling. As a result, when the number of eligible domains is less than minDomains, scheduler won't schedule more than maxSkew Pods to those domains. If value is nil, the constraint behaves as if MinDomains is equal to 1. Valid values are integers greater than 0. When value is not nil, WhenUnsatisfiable must be DoNotSchedule. + +For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | | P P | P P | P P | The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew. + +This is an alpha field and requires enabling MinDomainsInPodTopologySpread feature gate. +integer + + topologyKey"TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each as a "bucket", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes match the node selector. e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology. And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology. It's a required field. +string + +whenUnsatisfiable " WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location, + but giving higher precedence to topologies that would help reduce the + skew. +A constraint is considered "Unsatisfiable" for an incoming pod if and only if every possible node assignment for that pod would violate "MaxSkew" on some topology. For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same labelSelector spread as 3/1/1: | zone1 | zone2 | zone3 | | P P P | P | P | If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler won't make it *more* imbalanced. It's a required field. + +Possible enum values: + - `"DoNotSchedule"` instructs the scheduler not to schedule the pod when constraints are not satisfied. + - `"ScheduleAnyway"` instructs the scheduler to schedule the pod even if constraints are not satisfied.DoNotSchedule +ScheduleAnyway + +string + +,io.k8s.api.core.v1.TypedLocalObjectReference"~TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.kindname +object + +apiGroup"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. +string +B +kind:"-Kind is the type of resource being referenced +string +B +name:"-Name is the name of resource being referenced +string" +x-kubernetes-map-type atomic + +8 +io.k8s.api.core.v1.Volume8"[Volume represents a named volume in a pod that may be accessed by any container in the pod.name +object7 + +awsElasticBlockStore +A#/definitions/io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"awsElasticBlockStore represents an AWS Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore + + azureDisk +6#/definitions/io.k8s.api.core.v1.AzureDiskVolumeSource"TazureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. + + azureFile +6#/definitions/io.k8s.api.core.v1.AzureFileVolumeSource"WazureFile represents an Azure File Service mount on the host and bind mount to the pod. + +cephfs +3#/definitions/io.k8s.api.core.v1.CephFSVolumeSource"JcephFS represents a Ceph FS mount on the host that shares a pod's lifetime + +cinder +3#/definitions/io.k8s.api.core.v1.CinderVolumeSource"cinder represents a cinder volume attached and mounted on kubelets host machine. More info: https://examples.k8s.io/mysql-cinder-pd/README.md + + configMap{ +6#/definitions/io.k8s.api.core.v1.ConfigMapVolumeSource"AconfigMap represents a configMap that should populate this volume + +csi +0#/definitions/io.k8s.api.core.v1.CSIVolumeSource"~csi (Container Storage Interface) represents ephemeral storage that is handled by certain external CSI drivers (Beta feature). + + downwardAPI +8#/definitions/io.k8s.api.core.v1.DownwardAPIVolumeSource"RdownwardAPI represents downward API about the pod that should populate this volume + +emptyDir +5#/definitions/io.k8s.api.core.v1.EmptyDirVolumeSource"emptyDir represents a temporary directory that shares a pod's lifetime. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir + + ephemeral +6#/definitions/io.k8s.api.core.v1.EphemeralVolumeSource"ephemeral represents a volume that is handled by a cluster storage driver. The volume's lifecycle is tied to the pod that defines it - it will be created before the pod starts, and deleted when the pod is removed. + +Use this if: a) the volume is only needed while the pod runs, b) features of normal volumes like restoring from snapshot or capacity + tracking are needed, +c) the storage driver is specified through a storage class, and d) the storage driver supports dynamic volume provisioning through + a PersistentVolumeClaim (see EphemeralVolumeSource for more + information on the connection between this volume type + and PersistentVolumeClaim). + +Use PersistentVolumeClaim or one of the vendor-specific APIs for volumes that persist for longer than the lifecycle of an individual pod. + +Use CSI for light-weight local ephemeral volumes if the CSI driver is meant to be used that way - see the documentation of the driver for more information. + +A pod can use both types of ephemeral volumes and persistent volumes at the same time. + +fc +/#/definitions/io.k8s.api.core.v1.FCVolumeSource"pfc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod. + + +flexVolume +1#/definitions/io.k8s.api.core.v1.FlexVolumeSource"hflexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. + +flocker +4#/definitions/io.k8s.api.core.v1.FlockerVolumeSource"flocker represents a Flocker volume attached to a kubelet's host machine. This depends on the Flocker control service being running + +gcePersistentDisk +>#/definitions/io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"gcePersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + +gitRepo +4#/definitions/io.k8s.api.core.v1.GitRepoVolumeSource"gitRepo represents a git repository at a particular revision. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container. + + glusterfs +6#/definitions/io.k8s.api.core.v1.GlusterfsVolumeSource"glusterfs represents a Glusterfs mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/glusterfs/README.md + +hostPath +5#/definitions/io.k8s.api.core.v1.HostPathVolumeSource"hostPath represents a pre-existing file or directory on the host machine that is directly exposed to the container. This is generally used for system agents or other privileged things that are allowed to see the host machine. Most containers will NOT need this. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath + +iscsi +2#/definitions/io.k8s.api.core.v1.ISCSIVolumeSource"iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md + +name"name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names +string + +nfs +0#/definitions/io.k8s.api.core.v1.NFSVolumeSource"nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs + +persistentVolumeClaim +B#/definitions/io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims + +photonPersistentDisk +A#/definitions/io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"pphotonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine + +portworxVolume +5#/definitions/io.k8s.api.core.v1.PortworxVolumeSource"YportworxVolume represents a portworx volume attached and mounted on kubelets host machine + + projected +6#/definitions/io.k8s.api.core.v1.ProjectedVolumeSource"Nprojected items for all in one resources secrets, configmaps, and downward API + +quobyte +4#/definitions/io.k8s.api.core.v1.QuobyteVolumeSource"Kquobyte represents a Quobyte mount on the host that shares a pod's lifetime + +rbd +0#/definitions/io.k8s.api.core.v1.RBDVolumeSource"rbd represents a Rados Block Device mount on the host that shares a pod's lifetime. More info: https://examples.k8s.io/volumes/rbd/README.md + +scaleIO +4#/definitions/io.k8s.api.core.v1.ScaleIOVolumeSource"XscaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes. + +secret +3#/definitions/io.k8s.api.core.v1.SecretVolumeSource"secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret + + storageos +6#/definitions/io.k8s.api.core.v1.StorageOSVolumeSource"QstorageOS represents a StorageOS volume attached and mounted on Kubernetes nodes. + + vsphereVolume +?#/definitions/io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"WvsphereVolume represents a vSphere volume attached and mounted on kubelets host machine + +io.k8s.api.core.v1.VolumeDevice"JvolumeDevice describes a mapping of a raw block device within a container.name +devicePath +object +l + +devicePath^"QdevicePath is the path inside of the container that the device will be mapped to. +string +S +nameK">name must match the name of a persistentVolumeClaim in the pod +string + +io.k8s.api.core.v1.VolumeMount"@VolumeMount describes a mounting of a Volume within a container.name mountPath +object +q + mountPathd"WPath within the container at which the volume should be mounted. Must not contain ':'. +string + +mountPropagation"mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. +string +: +name2"%This must match the Name of a Volume. +string +t +readOnlyh"ZMounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. +boolean + +subPathx"kPath within the volume from which the container's volume should be mounted. Defaults to "" (volume's root). +string + + subPathExpr"Expanded path within the volume from which the container's volume should be mounted. Behaves similarly to SubPath but environment variable references $(VAR_NAME) are expanded using the container's environment. Defaults to "" (volume's root). SubPathExpr and SubPath are mutually exclusive. +string + +%io.k8s.api.core.v1.VolumeNodeAffinity"^VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from. +objecty +w +requiredk +-#/definitions/io.k8s.api.core.v1.NodeSelector":required specifies hard node constraints that must be met. + +#io.k8s.api.core.v1.VolumeProjection"HProjection that may be projected along with other supported volume types +object +~ + configMapq +4#/definitions/io.k8s.api.core.v1.ConfigMapProjection"9configMap information about the configMap data to project + + downwardAPIw +6#/definitions/io.k8s.api.core.v1.DownwardAPIProjection"=downwardAPI information about the downwardAPI data to project +r +secreth +1#/definitions/io.k8s.api.core.v1.SecretProjection"3secret information about the secret data to project + +serviceAccountToken +>#/definitions/io.k8s.api.core.v1.ServiceAccountTokenProjection"PserviceAccountToken is information about the serviceAccountToken data to project + +1io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"%Represents a vSphere volume resource. +volumePath +object + +fsType"fsType is filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. "ext4", "xfs", "ntfs". Implicitly inferred to be "ext4" if unspecified. +string + +storagePolicyID|"ostoragePolicyID is the storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. +string +o +storagePolicyNameZ"MstoragePolicyName is the storage Policy Based Management (SPBM) profile name. +string +U + +volumePathG":volumePath is the path that identifies vSphere volume vmdk +string + +*io.k8s.api.core.v1.WeightedPodAffinityTerm"vThe weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)weightpodAffinityTerm +object + +podAffinityTerm| +0#/definitions/io.k8s.api.core.v1.PodAffinityTerm"HRequired. A pod affinity term, associated with the corresponding weight. +u +weightkint32"Vweight associated with matching the corresponding podAffinityTerm, in the range 1-100. +integer + + +0io.k8s.api.core.v1.WindowsSecurityContextOptions +"OWindowsSecurityContextOptions contain Windows-specific options and credentials. +object + +gmsaCredentialSpec"GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field. +string +m +gmsaCredentialSpecNameS"FGMSACredentialSpecName is the name of the GMSA credential spec to use. +string + + hostProcess"HostProcess determines if a container should be run as a 'Host Process' container. This field is alpha-level and will only be honored by components that enable the WindowsHostProcessContainers feature flag. Setting this field without the feature flag will result in errors when validating the Pod. All of a Pod's containers must have the same effective HostProcess value (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers). In addition, if HostProcess is true then HostNetwork must also be set to true. +boolean + + runAsUserName"The UserName in Windows to run the entrypoint of the container process. Defaults to the user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. +string + + io.k8s.api.discovery.v1.Endpoint"FEndpoint represents a single logical "backend" implementing a service. addresses +object + + addresses"addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. These are all assumed to be fungible and clients may choose to only use the first element. Refer to: https://issue.k8s.io/106267 +array +  +string +x-kubernetes-list-typeset + + + +conditions +8#/definitions/io.k8s.api.discovery.v1.EndpointConditions"Iconditions contains information about the current status of the endpoint. + +deprecatedTopology"deprecatedTopology contains topology information part of the v1beta1 API. This field is deprecated, and will be removed when the v1beta1 API is removed (no sooner than kubernetes v1.24). While this field can hold values, it is not writable through the v1 API, and any attempts to write to it will be silently ignored. Topology information can be found in the zone and nodeName fields instead. +  +string +object + +hints +3#/definitions/io.k8s.api.discovery.v1.EndpointHints"Nhints contains information associated with how an endpoint should be consumed. + +hostname"hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must be lowercase and pass DNS Label (RFC 1123) validation. +string + +nodeName"nodeName represents the name of the Node hosting this endpoint. This can be used to determine endpoints local to a Node. This field can be enabled with the EndpointSliceNodeName feature gate. +string + + targetRef +0#/definitions/io.k8s.api.core.v1.ObjectReference"NtargetRef is a reference to a Kubernetes object that represents this endpoint. +J +zoneB"5zone is the name of the Zone this endpoint exists in. +string + +*io.k8s.api.discovery.v1.EndpointConditions"CEndpointConditions represents the current condition of an endpoint. +object + +ready"ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. For compatibility reasons, ready should never be "true" for terminating endpoints. +boolean + +serving"serving is identical to ready except that it is set regardless of the terminating state of endpoints. This condition should be set to true for a ready endpoint that is terminating. If nil, consumers should defer to the ready condition. This field can be enabled with the EndpointSliceTerminatingCondition feature gate. +boolean + + terminating"terminating indicates that this endpoint is terminating. A nil value indicates an unknown state. Consumers should interpret this unknown state to mean that the endpoint is not terminating. This field can be enabled with the EndpointSliceTerminatingCondition feature gate. +boolean + +%io.k8s.api.discovery.v1.EndpointHints"KEndpointHints provides hints describing how an endpoint should be consumed. +object + +forZones"dforZones indicates the zone(s) this endpoint should be consumed by to enable topology aware routing. +array1 +/ +-#/definitions/io.k8s.api.discovery.v1.ForZone# +x-kubernetes-list-type atomic + + +$io.k8s.api.discovery.v1.EndpointPort "7EndpointPort represents a Port used by an EndpointSlice +object + + appProtocol"The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names such as mycompany.com/my-custom-protocol. +string + +name"The name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is dervied from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string. +string + +portint32"The port number of the endpoint. If this is not specified, ports are not restricted and must be interpreted in the context of the specific consumer. +integer +b +protocolV"IThe IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP. +string" +x-kubernetes-map-type atomic + + +%io.k8s.api.discovery.v1.EndpointSlice"EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. addressType endpoints +object + + addressType"addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. + +Possible enum values: + - `"FQDN"` represents a FQDN. + - `"IPv4"` represents an IPv4 Address. + - `"IPv6"` represents an IPv6 Address.FQDN +IPv4 +IPv6 + +string + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + endpoints"jendpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints. +array2 +0 +.#/definitions/io.k8s.api.discovery.v1.Endpoint# +x-kubernetes-list-type atomic + + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. + +ports"ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. When ports is empty, it indicates that there are no defined ports. When a port is defined with a nil port value, it indicates "all ports". Each slice may include a maximum of 100 ports. +array6 +4 +2#/definitions/io.k8s.api.discovery.v1.EndpointPort# +x-kubernetes-list-type atomic +c +x-kubernetes-group-version-kind@>- group: discovery.k8s.io + kind: EndpointSlice + version: v1 + + +)io.k8s.api.discovery.v1.EndpointSliceList"6EndpointSliceList represents a list of endpoint slicesitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +f +items]"List of endpoint slices +array7 +5 +3#/definitions/io.k8s.api.discovery.v1.EndpointSlice + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +b +metadataV +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata.g +x-kubernetes-group-version-kindDB- group: discovery.k8s.io + kind: EndpointSliceList + version: v1 + + +io.k8s.api.discovery.v1.ForZone"LForZone provides information about which zones should consume this endpoint.name +object< +: +name2"%name represents the name of the zone. +string + +%io.k8s.api.discovery.v1beta1.Endpoint"FEndpoint represents a single logical "backend" implementing a service. addresses +object + + addresses"addresses of this endpoint. The contents of this field are interpreted according to the corresponding EndpointSlice addressType field. Consumers must handle different types of addresses in the context of their own capabilities. This must contain at least one address but no more than 100. These are all assumed to be fungible and clients may choose to only use the first element. Refer to: https://issue.k8s.io/106267 +array +  +string +x-kubernetes-list-typeset + + + +conditions +=#/definitions/io.k8s.api.discovery.v1beta1.EndpointConditions"Iconditions contains information about the current status of the endpoint. + +hints +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointHints"Nhints contains information associated with how an endpoint should be consumed. + +hostname"hostname of this endpoint. This field may be used by consumers of endpoints to distinguish endpoints from each other (e.g. in DNS names). Multiple endpoints which use the same hostname should be considered fungible (e.g. multiple A values in DNS). Must be lowercase and pass DNS Label (RFC 1123) validation. +string + +nodeName"nodeName represents the name of the Node hosting this endpoint. This can be used to determine endpoints local to a Node. This field can be enabled with the EndpointSliceNodeName feature gate. +string + + targetRef +0#/definitions/io.k8s.api.core.v1.ObjectReference"NtargetRef is a reference to a Kubernetes object that represents this endpoint. + +topology"topology contains arbitrary topology information associated with the endpoint. These key/value pairs must conform with the label format. https://kubernetes.io/docs/concepts/overview/working-with-objects/labels Topology may include a maximum of 16 key/value pairs. This includes, but is not limited to the following well known keys: * kubernetes.io/hostname: the value indicates the hostname of the node + where the endpoint is located. This should match the corresponding + node label. +* topology.kubernetes.io/zone: the value indicates the zone where the + endpoint is located. This should match the corresponding node label. +* topology.kubernetes.io/region: the value indicates the region where the + endpoint is located. This should match the corresponding node label. +This field is deprecated and will be removed in future api versions. +  +string +object + +/io.k8s.api.discovery.v1beta1.EndpointConditions"CEndpointConditions represents the current condition of an endpoint. +object + +ready"ready indicates that this endpoint is prepared to receive traffic, according to whatever system is managing the endpoint. A nil value indicates an unknown state. In most cases consumers should interpret this unknown state as ready. For compatibility reasons, ready should never be "true" for terminating endpoints. +boolean + +serving"serving is identical to ready except that it is set regardless of the terminating state of endpoints. This condition should be set to true for a ready endpoint that is terminating. If nil, consumers should defer to the ready condition. This field can be enabled with the EndpointSliceTerminatingCondition feature gate. +boolean + + terminating"terminating indicates that this endpoint is terminating. A nil value indicates an unknown state. Consumers should interpret this unknown state to mean that the endpoint is not terminating. This field can be enabled with the EndpointSliceTerminatingCondition feature gate. +boolean + +*io.k8s.api.discovery.v1beta1.EndpointHints"KEndpointHints provides hints describing how an endpoint should be consumed. +object + +forZones"forZones indicates the zone(s) this endpoint should be consumed by to enable topology aware routing. May contain a maximum of 8 entries. +array6 +4 +2#/definitions/io.k8s.api.discovery.v1beta1.ForZone# +x-kubernetes-list-type atomic + + +)io.k8s.api.discovery.v1beta1.EndpointPort "7EndpointPort represents a Port used by an EndpointSlice +object + + appProtocol"The application protocol for this port. This field follows standard Kubernetes label syntax. Un-prefixed names are reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names). Non-standard protocols should use prefixed names such as mycompany.com/my-custom-protocol. +string + +name"The name of this port. All ports in an EndpointSlice must have a unique name. If the EndpointSlice is dervied from a Kubernetes service, this corresponds to the Service.ports[].name. Name must either be an empty string or pass DNS_LABEL validation: * must be no more than 63 characters long. * must consist of lower case alphanumeric characters or '-'. * must start and end with an alphanumeric character. Default is empty string. +string + +portint32"The port number of the endpoint. If this is not specified, ports are not restricted and must be interpreted in the context of the specific consumer. +integer +b +protocolV"IThe IP protocol for this port. Must be UDP, TCP, or SCTP. Default is TCP. +string + +*io.k8s.api.discovery.v1beta1.EndpointSlice"EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints. addressType endpoints +object + + addressType"addressType specifies the type of address carried by this EndpointSlice. All addresses in this slice must be the same type. This field is immutable after creation. The following address types are currently supported: * IPv4: Represents an IPv4 Address. * IPv6: Represents an IPv6 Address. * FQDN: Represents a Fully Qualified Domain Name. +string + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + endpoints"jendpoints is a list of unique endpoints in this slice. Each slice may include a maximum of 1000 endpoints. +array7 +5 +3#/definitions/io.k8s.api.discovery.v1beta1.Endpoint# +x-kubernetes-list-type atomic + + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. + +ports"ports specifies the list of network ports exposed by each endpoint in this slice. Each port must have a unique name. When ports is empty, it indicates that there are no defined ports. When a port is defined with a nil port value, it indicates "all ports". Each slice may include a maximum of 100 ports. +array; +9 +7#/definitions/io.k8s.api.discovery.v1beta1.EndpointPort# +x-kubernetes-list-type atomic +h +x-kubernetes-group-version-kindEC- group: discovery.k8s.io + kind: EndpointSlice + version: v1beta1 + + +.io.k8s.api.discovery.v1beta1.EndpointSliceList"6EndpointSliceList represents a list of endpoint slicesitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +k +itemsb"List of endpoint slices +array< +: +8#/definitions/io.k8s.api.discovery.v1beta1.EndpointSlice + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +b +metadataV +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata.l +x-kubernetes-group-version-kindIG- group: discovery.k8s.io + kind: EndpointSliceList + version: v1beta1 + + +$io.k8s.api.discovery.v1beta1.ForZone"LForZone provides information about which zones should consume this endpoint.name +object< +: +name2"%name represents the name of the zone. +string + +io.k8s.api.events.v1.Event"Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. eventTime +object + +action"action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field cannot be empty for new Events and it can have at most 128 characters. +string + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +deprecatedCountuint32"`deprecatedCount is the deprecated field assuring backward compatibility with core.v1 Event type. +integer + +deprecatedFirstTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"ideprecatedFirstTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type. + +deprecatedLastTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"hdeprecatedLastTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type. + +deprecatedSource +,#/definitions/io.k8s.api.core.v1.EventSource"adeprecatedSource is the deprecated field assuring backward compatibility with core.v1 Event type. + + eventTime +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"IeventTime is the time when this Event was first observed. It is required. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +note"note is a human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB. +string + +reason"reason is why the action was taken. It is human-readable. This field cannot be empty for new Events and it can have at most 128 characters. +string + + regarding +0#/definitions/io.k8s.api.core.v1.ObjectReference"regarding contains the object this Event is about. In most cases it's an Object reporting controller implements, e.g. ReplicaSetController implements ReplicaSets and this event is emitted because it acts on some changes in a ReplicaSet object. + +related +0#/definitions/io.k8s.api.core.v1.ObjectReference"related is the optional secondary object for more complex actions. E.g. when regarding object triggers a creation or deletion of related object. + +reportingController"reportingController is the name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. This field cannot be empty for new Events. +string + +reportingInstance"reportingInstance is the ID of the controller instance, e.g. `kubelet-xyzf`. This field cannot be empty for new Events and it can have at most 128 characters. +string + +series +.#/definitions/io.k8s.api.events.v1.EventSeries"]series is data about the Event series this event represents or nil if it's a singleton Event. + +type"type is the type of this event (Normal, Warning), new types could be added in the future. It is machine-readable. This field cannot be empty for new Events. +stringX +x-kubernetes-group-version-kind53- group: events.k8s.io + kind: Event + version: v1 + + +io.k8s.api.events.v1.EventList"%EventList is a list of Event objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +f +items]""items is a list of schema objects. +array, +* +(#/definitions/io.k8s.api.events.v1.Event + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata\ +x-kubernetes-group-version-kind97- group: events.k8s.io + kind: EventList + version: v1 + + + io.k8s.api.events.v1.EventSeries"EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in "k8s.io/client-go/tools/events/event_broadcaster.go" shows how this struct is updated on heartbeats and can guide customized reporter implementations.countlastObservedTime +object +n +counteint32"Pcount is the number of occurrences in this series up to the last heartbeat time. +integer + +lastObservedTime +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"\lastObservedTime is the time when last Event from the series was seen before last heartbeat. + +io.k8s.api.events.v1beta1.Event"Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data. eventTime +object + +action"action is what action was taken/failed regarding to the regarding object. It is machine-readable. This field can have at most 128 characters. +string + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +deprecatedCountuint32"`deprecatedCount is the deprecated field assuring backward compatibility with core.v1 Event type. +integer + +deprecatedFirstTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"ideprecatedFirstTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type. + +deprecatedLastTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"hdeprecatedLastTimestamp is the deprecated field assuring backward compatibility with core.v1 Event type. + +deprecatedSource +,#/definitions/io.k8s.api.core.v1.EventSource"adeprecatedSource is the deprecated field assuring backward compatibility with core.v1 Event type. + + eventTime +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"IeventTime is the time when this Event was first observed. It is required. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +note"note is a human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB. +string +| +reasonr"ereason is why the action was taken. It is human-readable. This field can have at most 128 characters. +string + + regarding +0#/definitions/io.k8s.api.core.v1.ObjectReference"regarding contains the object this Event is about. In most cases it's an Object reporting controller implements, e.g. ReplicaSetController implements ReplicaSets and this event is emitted because it acts on some changes in a ReplicaSet object. + +related +0#/definitions/io.k8s.api.core.v1.ObjectReference"related is the optional secondary object for more complex actions. E.g. when regarding object triggers a creation or deletion of related object. + +reportingController"reportingController is the name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. This field cannot be empty for new Events. +string + +reportingInstance"reportingInstance is the ID of the controller instance, e.g. `kubelet-xyzf`. This field cannot be empty for new Events and it can have at most 128 characters. +string + +series +3#/definitions/io.k8s.api.events.v1beta1.EventSeries"]series is data about the Event series this event represents or nil if it's a singleton Event. + +type~"qtype is the type of this event (Normal, Warning), new types could be added in the future. It is machine-readable. +string] +x-kubernetes-group-version-kind:8- group: events.k8s.io + kind: Event + version: v1beta1 + + +#io.k8s.api.events.v1beta1.EventList"%EventList is a list of Event objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +k +itemsb""items is a list of schema objects. +array1 +/ +-#/definitions/io.k8s.api.events.v1beta1.Event + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataa +x-kubernetes-group-version-kind><- group: events.k8s.io + kind: EventList + version: v1beta1 + + +%io.k8s.api.events.v1beta1.EventSeries"qEventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.countlastObservedTime +object +n +counteint32"Pcount is the number of occurrences in this series up to the last heartbeat time. +integer + +lastObservedTime +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"\lastObservedTime is the time when last Event from the series was seen before last heartbeat. + +6io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod"EFlowDistinguisherMethod specifies the method of a flow distinguisher.type +object + +typez"m`type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. +string + +)io.k8s.api.flowcontrol.v1beta1.FlowSchema "FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +;#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec"`spec` is the specification of the desired behavior of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +=#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus"`status` is the current status of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusq +x-kubernetes-group-version-kindNL- group: flowcontrol.apiserver.k8s.io + kind: FlowSchema + version: v1beta1 + + +2io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition":FlowSchemaCondition describes conditions for a FlowSchema. +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"\`lastTransitionTime` is the last time the condition transitioned from one status to another. +g +message\"O`message` is a human-readable message indicating details about last transition. +string +l +reasonb"U`reason` is a unique, one-word, CamelCase reason for the condition's last transition. +string +f +status\"O`status` is the status of the condition. Can be True, False, Unknown. Required. +string +C +type;".`type` is the type of the condition. Required. +string + +-io.k8s.api.flowcontrol.v1beta1.FlowSchemaList "/FlowSchemaList is a list of FlowSchema objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +t +itemsk"!`items` is a list of FlowSchemas. +array; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchema + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"`metadata` is the standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatau +x-kubernetes-group-version-kindRP- group: flowcontrol.apiserver.k8s.io + kind: FlowSchemaList + version: v1beta1 + + +-io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec "GFlowSchemaSpec describes how the FlowSchema's specification looks like.priorityLevelConfiguration +object + + +distinguisherMethod +D#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod"`distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. + +matchingPrecedenceint32"`matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen FlowSchema is among those with the numerically lowest (which we take to be logically highest) MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000]. Note that if the precedence is not specified, it will be set to 1000 as default. +integer + +priorityLevelConfiguration +P#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference"`priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot be resolved, the FlowSchema will be ignored and marked as invalid in its status. Required. + +rules"`rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if at least one member of rules matches the request. if it is an empty slice, there will be no requests matching the FlowSchema. +arrayH +F +D#/definitions/io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects# +x-kubernetes-list-type atomic + + +/io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus">FlowSchemaStatus represents the current state of a FlowSchema. +object + + +conditions";`conditions` is a list of the current states of FlowSchema. +arrayD +B +@#/definitions/io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + ++io.k8s.api.flowcontrol.v1beta1.GroupSubject"?GroupSubject holds detailed information for group-kind subject.name +object + +name"name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. +string + +,io.k8s.api.flowcontrol.v1beta1.LimitResponse"PLimitResponse defines how to handle requests that can not be executed right now.type +object + +queuing +A#/definitions/io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration"r`queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. + +type"`type` is "Queue" or "Reject". "Queue" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. "Reject" means that requests that can not be executed upon arrival are rejected. Required. +string` +x-kubernetes-unionsIG- discriminator: type + fields-to-discriminateBy: + queuing: Queuing + + +@io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration "LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: + * How are requests for this priority level limited? + * What should be done with requests that exceed the limit? +object + +assuredConcurrencySharesint32"`assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: + + ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) + +bigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30. +integer + + limitResponse +:#/definitions/io.k8s.api.flowcontrol.v1beta1.LimitResponse"U`limitResponse` indicates what to do with requests that can not be executed right now + +4io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule"NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.verbsnonResourceURLs +object + +nonResourceURLs"`nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: + - "/healthz" is legal + - "/hea*" is illegal + - "/hea" is legal but matches nothing + - "/hea/*" also matches nothing + - "/healthz/*" matches all per-component health checks. +"*" matches all non-resource urls. if it is present, it must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +verbs"`verbs` is a list of matching verbs and may not be empty. "*" matches all verbs. If it is present, it must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +6io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects "PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request.subjects +object + +nonResourceRules"`nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. +arrayF +D +B#/definitions/io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule# +x-kubernetes-list-type atomic + + + resourceRules"`resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the target resource. At least one of `resourceRules` and `nonResourceRules` has to be non-empty. +arrayC +A +?#/definitions/io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule# +x-kubernetes-list-type atomic + + +subjects"subjects is the list of normal user, serviceaccount, or group that this rule cares about. There must be at least one member in this slice. A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. Required. +array8 +6 +4#/definitions/io.k8s.api.flowcontrol.v1beta1.Subject# +x-kubernetes-list-type atomic + + +9io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration "LPriorityLevelConfiguration represents the configuration of a priority level. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +K#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec"`spec` is the specification of the desired behavior of a "request-priority". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +M#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus"`status` is the current status of a "request-priority". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status +x-kubernetes-group-version-kind^\- group: flowcontrol.apiserver.k8s.io + kind: PriorityLevelConfiguration + version: v1beta1 + + +Bio.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition"LPriorityLevelConfigurationCondition defines the condition of priority level. +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"\`lastTransitionTime` is the last time the condition transitioned from one status to another. +g +message\"O`message` is a human-readable message indicating details about last transition. +string +l +reasonb"U`reason` is a unique, one-word, CamelCase reason for the condition's last transition. +string +f +status\"O`status` is the status of the condition. Can be True, False, Unknown. Required. +string +C +type;".`type` is the type of the condition. Required. +string + + +=io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationList "OPriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"(`items` is a list of request-priorities. +arrayK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +x-kubernetes-group-version-kindb`- group: flowcontrol.apiserver.k8s.io + kind: PriorityLevelConfigurationList + version: v1beta1 + + +Bio.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference"jPriorityLevelConfigurationReference contains information that points to the "request-priority" being used.name +objecth +f +name^"Q`name` is the name of the priority level configuration being referenced Required. +string + +=io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec"OPriorityLevelConfigurationSpec specifies the configuration of a priority level.type +object + +limited +N#/definitions/io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration"`limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. + +type"`type` indicates whether this priority level is subject to limitation on request execution. A value of `"Exempt"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `"Limited"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required. +string` +x-kubernetes-unionsIG- discriminator: type + fields-to-discriminateBy: + limited: Limited + + +?io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus"VPriorityLevelConfigurationStatus represents the current state of a "request-priority". +object + + +conditions"8`conditions` is the current state of "request-priority". +arrayT +R +P#/definitions/io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + +3io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration +"CQueuingConfiguration holds the configuration parameters for queuing +object + + +handSizeint32"`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. +integer + +queueLengthLimitint32"`queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50. +integer + +queuesint32"`queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64. +integer + +1io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule"ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace.verbs apiGroups resources +object + + apiGroups"`apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + + clusterScope"`clusterScope` indicates whether to match requests that do not specify a namespace (which happens either because the resource is not namespaced or the request targets all namespaces). If this field is omitted or false then the `namespaces` field must contain a non-empty list. +boolean + + +namespaces"`namespaces` is a list of target namespaces that restricts matches. A request that specifies a target namespace matches only if either (a) this list contains that target namespace or (b) this list contains "*". Note that "*" matches any specified namespace but does not match a request that _does not specify_ a namespace (see the `clusterScope` field for that). This list may be empty, but only if `clusterScope` is true. +array +  +string +x-kubernetes-list-typeset + + + resources"`resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ "services", "nodes/status" ]. This list may not be empty. "*" matches all resources and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +verbs"`verbs` is a list of matching verbs and may not be empty. "*" matches all verbs and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +4io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject"RServiceAccountSubject holds detailed information for service-account-kind subject. namespacename +object +y +nameq"d`name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. +string +d + namespaceW"J`namespace` is the namespace of matching ServiceAccount objects. Required. +string + +&io.k8s.api.flowcontrol.v1beta1.Subject"Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account.kind +object +o +groupf +9#/definitions/io.k8s.api.flowcontrol.v1beta1.GroupSubject")`group` matches based on user group name. +Z +kindR"E`kind` indicates which one of the other fields is non-empty. Required +string + +serviceAccounto +B#/definitions/io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject")`serviceAccount` matches ServiceAccounts. +e +user] +8#/definitions/io.k8s.api.flowcontrol.v1beta1.UserSubject"!`user` matches based on username. +x-kubernetes-unionswu- discriminator: kind + fields-to-discriminateBy: + group: Group + serviceAccount: ServiceAccount + user: User + + +*io.k8s.api.flowcontrol.v1beta1.UserSubject"=UserSubject holds detailed information for user-kind subject.name +objectd +b +nameZ"M`name` is the username that matches, or "*" to match all usernames. Required. +string + +6io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod"EFlowDistinguisherMethod specifies the method of a flow distinguisher.type +object + +typez"m`type` is the type of flow distinguisher method The supported types are "ByUser" and "ByNamespace". Required. +string + +)io.k8s.api.flowcontrol.v1beta2.FlowSchema "FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher". +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +;#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec"`spec` is the specification of the desired behavior of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +=#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus"`status` is the current status of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusq +x-kubernetes-group-version-kindNL- group: flowcontrol.apiserver.k8s.io + kind: FlowSchema + version: v1beta2 + + +2io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition":FlowSchemaCondition describes conditions for a FlowSchema. +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"\`lastTransitionTime` is the last time the condition transitioned from one status to another. +g +message\"O`message` is a human-readable message indicating details about last transition. +string +l +reasonb"U`reason` is a unique, one-word, CamelCase reason for the condition's last transition. +string +f +status\"O`status` is the status of the condition. Can be True, False, Unknown. Required. +string +C +type;".`type` is the type of the condition. Required. +string + +-io.k8s.api.flowcontrol.v1beta2.FlowSchemaList "/FlowSchemaList is a list of FlowSchema objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +t +itemsk"!`items` is a list of FlowSchemas. +array; +9 +7#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchema + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"`metadata` is the standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatau +x-kubernetes-group-version-kindRP- group: flowcontrol.apiserver.k8s.io + kind: FlowSchemaList + version: v1beta2 + + +-io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec "GFlowSchemaSpec describes how the FlowSchema's specification looks like.priorityLevelConfiguration +object + + +distinguisherMethod +D#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod"`distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema. `nil` specifies that the distinguisher is disabled and thus will always be the empty string. + +matchingPrecedenceint32"`matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen FlowSchema is among those with the numerically lowest (which we take to be logically highest) MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000]. Note that if the precedence is not specified, it will be set to 1000 as default. +integer + +priorityLevelConfiguration +P#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference"`priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot be resolved, the FlowSchema will be ignored and marked as invalid in its status. Required. + +rules"`rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if at least one member of rules matches the request. if it is an empty slice, there will be no requests matching the FlowSchema. +arrayH +F +D#/definitions/io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects# +x-kubernetes-list-type atomic + + +/io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus">FlowSchemaStatus represents the current state of a FlowSchema. +object + + +conditions";`conditions` is a list of the current states of FlowSchema. +arrayD +B +@#/definitions/io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + ++io.k8s.api.flowcontrol.v1beta2.GroupSubject"?GroupSubject holds detailed information for group-kind subject.name +object + +name"name is the user group that matches, or "*" to match all user groups. See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some well-known group names. Required. +string + +,io.k8s.api.flowcontrol.v1beta2.LimitResponse"PLimitResponse defines how to handle requests that can not be executed right now.type +object + +queuing +A#/definitions/io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration"r`queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `"Queue"`. + +type"`type` is "Queue" or "Reject". "Queue" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. "Reject" means that requests that can not be executed upon arrival are rejected. Required. +string` +x-kubernetes-unionsIG- discriminator: type + fields-to-discriminateBy: + queuing: Queuing + + +@io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration "LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues: + * How are requests for this priority level limited? + * What should be done with requests that exceed the limit? +object + +assuredConcurrencySharesint32"`assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level: + + ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) ) + +bigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30. +integer + + limitResponse +:#/definitions/io.k8s.api.flowcontrol.v1beta2.LimitResponse"U`limitResponse` indicates what to do with requests that can not be executed right now + +4io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule"NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.verbsnonResourceURLs +object + +nonResourceURLs"`nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty. For example: + - "/healthz" is legal + - "/hea*" is illegal + - "/hea" is legal but matches nothing + - "/hea/*" also matches nothing + - "/healthz/*" matches all per-component health checks. +"*" matches all non-resource urls. if it is present, it must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +verbs"`verbs` is a list of matching verbs and may not be empty. "*" matches all verbs. If it is present, it must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +6io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects "PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member of resourceRules or nonResourceRules matches the request.subjects +object + +nonResourceRules"`nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb and the target non-resource URL. +arrayF +D +B#/definitions/io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule# +x-kubernetes-list-type atomic + + + resourceRules"`resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the target resource. At least one of `resourceRules` and `nonResourceRules` has to be non-empty. +arrayC +A +?#/definitions/io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule# +x-kubernetes-list-type atomic + + +subjects"subjects is the list of normal user, serviceaccount, or group that this rule cares about. There must be at least one member in this slice. A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request. Required. +array8 +6 +4#/definitions/io.k8s.api.flowcontrol.v1beta2.Subject# +x-kubernetes-list-type atomic + + +9io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration "LPriorityLevelConfiguration represents the configuration of a priority level. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +K#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec"`spec` is the specification of the desired behavior of a "request-priority". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +M#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus"`status` is the current status of a "request-priority". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status +x-kubernetes-group-version-kind^\- group: flowcontrol.apiserver.k8s.io + kind: PriorityLevelConfiguration + version: v1beta2 + + +Bio.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition"LPriorityLevelConfigurationCondition defines the condition of priority level. +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"\`lastTransitionTime` is the last time the condition transitioned from one status to another. +g +message\"O`message` is a human-readable message indicating details about last transition. +string +l +reasonb"U`reason` is a unique, one-word, CamelCase reason for the condition's last transition. +string +f +status\"O`status` is the status of the condition. Can be True, False, Unknown. Required. +string +C +type;".`type` is the type of the condition. Required. +string + + +=io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationList "OPriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"(`items` is a list of request-priorities. +arrayK +I +G#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"`metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +x-kubernetes-group-version-kindb`- group: flowcontrol.apiserver.k8s.io + kind: PriorityLevelConfigurationList + version: v1beta2 + + +Bio.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference"jPriorityLevelConfigurationReference contains information that points to the "request-priority" being used.name +objecth +f +name^"Q`name` is the name of the priority level configuration being referenced Required. +string + +=io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec"OPriorityLevelConfigurationSpec specifies the configuration of a priority level.type +object + +limited +N#/definitions/io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration"`limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `"Limited"`. + +type"`type` indicates whether this priority level is subject to limitation on request execution. A value of `"Exempt"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `"Limited"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required. +string` +x-kubernetes-unionsIG- discriminator: type + fields-to-discriminateBy: + limited: Limited + + +?io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus"VPriorityLevelConfigurationStatus represents the current state of a "request-priority". +object + + +conditions"8`conditions` is the current state of "request-priority". +arrayT +R +P#/definitions/io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + +3io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration +"CQueuingConfiguration holds the configuration parameters for queuing +object + + +handSizeint32"`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8. +integer + +queueLengthLimitint32"`queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50. +integer + +queuesint32"`queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64. +integer + +1io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule"ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target resource. A ResourcePolicyRule matches a resource request if and only if: (a) at least one member of verbs matches the request, (b) at least one member of apiGroups matches the request, (c) at least one member of resources matches the request, and (d) either (d1) the request does not specify a namespace (i.e., `Namespace==""`) and clusterScope is true or (d2) the request specifies a namespace and least one member of namespaces matches the request's namespace.verbs apiGroups resources +object + + apiGroups"`apiGroups` is a list of matching API groups and may not be empty. "*" matches all API groups and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + + clusterScope"`clusterScope` indicates whether to match requests that do not specify a namespace (which happens either because the resource is not namespaced or the request targets all namespaces). If this field is omitted or false then the `namespaces` field must contain a non-empty list. +boolean + + +namespaces"`namespaces` is a list of target namespaces that restricts matches. A request that specifies a target namespace matches only if either (a) this list contains that target namespace or (b) this list contains "*". Note that "*" matches any specified namespace but does not match a request that _does not specify_ a namespace (see the `clusterScope` field for that). This list may be empty, but only if `clusterScope` is true. +array +  +string +x-kubernetes-list-typeset + + + resources"`resources` is a list of matching resources (i.e., lowercase and plural) with, if desired, subresource. For example, [ "services", "nodes/status" ]. This list may not be empty. "*" matches all resources and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +verbs"`verbs` is a list of matching verbs and may not be empty. "*" matches all verbs and, if present, must be the only entry. Required. +array +  +string +x-kubernetes-list-typeset + + +4io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject"RServiceAccountSubject holds detailed information for service-account-kind subject. namespacename +object +y +nameq"d`name` is the name of matching ServiceAccount objects, or "*" to match regardless of name. Required. +string +d + namespaceW"J`namespace` is the namespace of matching ServiceAccount objects. Required. +string + +&io.k8s.api.flowcontrol.v1beta2.Subject"Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account.kind +object +o +groupf +9#/definitions/io.k8s.api.flowcontrol.v1beta2.GroupSubject")`group` matches based on user group name. +Z +kindR"E`kind` indicates which one of the other fields is non-empty. Required +string + +serviceAccounto +B#/definitions/io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject")`serviceAccount` matches ServiceAccounts. +e +user] +8#/definitions/io.k8s.api.flowcontrol.v1beta2.UserSubject"!`user` matches based on username. +x-kubernetes-unionswu- discriminator: kind + fields-to-discriminateBy: + group: Group + serviceAccount: ServiceAccount + user: User + + +*io.k8s.api.flowcontrol.v1beta2.UserSubject"=UserSubject holds detailed information for user-kind subject.name +objectd +b +nameZ"M`name` is the username that matches, or "*" to match all usernames. Required. +string + +(io.k8s.api.networking.v1.HTTPIngressPath "oHTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend.pathTypebackend +object + + +backend +5#/definitions/io.k8s.api.networking.v1.IngressBackend"ZBackend defines the referenced service endpoint to which the traffic will be forwarded to. + +path"Path is matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional "path" part of a URL as defined by RFC 3986. Paths must begin with a '/' and must be present when using PathType with value "Exact" or "Prefix". +string + +pathType"PathType determines the interpretation of the Path matching. PathType can be one of the following values: * Exact: Matches the URL path exactly. * Prefix: Matches based on a URL path prefix split by '/'. Matching is + done on a path element by element basis. A path element refers is the + list of labels in the path split by the '/' separator. A request is a + match for path p if every p is an element-wise prefix of p of the + request path. Note that if the last element of the path is a substring + of the last element in request path, it is not a match (e.g. /foo/bar + matches /foo/bar/baz, but does not match /foo/barbaz). +* ImplementationSpecific: Interpretation of the Path matching is up to + the IngressClass. Implementations can treat this as a separate PathType + or treat it identically to Prefix or Exact path types. +Implementations are required to support all path types. +string + +-io.k8s.api.networking.v1.HTTPIngressRuleValue"HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'.paths +object + +paths"4A collection of paths that map requests to backends. +array: +8 +6#/definitions/io.k8s.api.networking.v1.HTTPIngressPath# +x-kubernetes-list-type atomic + + + io.k8s.api.networking.v1.IPBlock"IPBlock describes a particular CIDR (Ex. "192.168.1.1/24","2001:db9::/64") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.cidr +object +v +cidrn"aCIDR is a string representing the IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64" +string + +except"Except is a slice of CIDRs that should not be included within an IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64" Except values will be rejected if they are outside the CIDR range +array +  +string + + io.k8s.api.networking.v1.Ingress "Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +2#/definitions/io.k8s.api.networking.v1.IngressSpec"Spec is the desired state of the Ingress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status + +status +4#/definitions/io.k8s.api.networking.v1.IngressStatus"Status is the current state of the Ingress. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status^ +x-kubernetes-group-version-kind;9- group: networking.k8s.io + kind: Ingress + version: v1 + + +'io.k8s.api.networking.v1.IngressBackend"DIngressBackend describes all endpoints for a given service and port. +object + +resource +:#/definitions/io.k8s.api.core.v1.TypedLocalObjectReference"Resource is an ObjectRef to another Kubernetes resource in the namespace of the Ingress object. If resource is specified, a service.Name and service.Port must not be specified. This is a mutually exclusive setting with "Service". + +service +<#/definitions/io.k8s.api.networking.v1.IngressServiceBackend"`Service references a Service as a Backend. This is a mutually exclusive setting with "Resource". + +%io.k8s.api.networking.v1.IngressClass "IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +7#/definitions/io.k8s.api.networking.v1.IngressClassSpec"Spec is the desired state of the IngressClass. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusc +x-kubernetes-group-version-kind@>- group: networking.k8s.io + kind: IngressClass + version: v1 + + +)io.k8s.api.networking.v1.IngressClassList"3IngressClassList is a collection of IngressClasses.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +s +itemsj"$Items is the list of IngressClasses. +array7 +5 +3#/definitions/io.k8s.api.networking.v1.IngressClass + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +b +metadataV +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata.g +x-kubernetes-group-version-kindDB- group: networking.k8s.io + kind: IngressClassList + version: v1 + + +8io.k8s.api.networking.v1.IngressClassParametersReference"}IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource.kindname +object + +apiGroup"APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. +string +C +kind;".Kind is the type of resource being referenced. +string +C +name;".Name is the name of resource being referenced. +string + + namespace"Namespace is the namespace of the resource being referenced. This field is required when scope is set to "Namespace" and must be unset when scope is set to "Cluster". +string + +scope"Scope represents if this refers to a cluster or namespace scoped resource. This may be set to "Cluster" (default) or "Namespace". +string + +)io.k8s.api.networking.v1.IngressClassSpec"DIngressClassSpec provides information about the class of an Ingress. +object + + +controller"Controller refers to the name of the controller that should handle this class. This allows for different "flavors" that are controlled by the same controller. For example, you may have different Parameters for the same implementing controller. This should be specified as a domain-prefixed path no more than 250 characters in length, e.g. "acme.io/ingress-controller". This field is immutable. +string + + +parameters +F#/definitions/io.k8s.api.networking.v1.IngressClassParametersReference"Parameters is a link to a custom resource containing additional configuration for the controller. This is optional if the controller does not require extra parameters. + +$io.k8s.api.networking.v1.IngressList"'IngressList is a collection of Ingress.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +g +items^"Items is the list of Ingress. +array2 +0 +.#/definitions/io.k8s.api.networking.v1.Ingress + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatab +x-kubernetes-group-version-kind?=- group: networking.k8s.io + kind: IngressList + version: v1 + + +$io.k8s.api.networking.v1.IngressRule "IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. +object + + +host +" +Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the "host" part of the URI as defined in RFC 3986: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to + the IP in the Spec of the parent Ingress. +2. The `:` delimiter is not respected because ports are not allowed. + Currently the port of an Ingress is implicitly :80 for http and + :443 for https. +Both these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue. + +Host can be "precise" which is a domain name without the terminating dot of a network host (e.g. "foo.bar.com") or "wildcard", which is a domain name prefixed with a single wildcard label (e.g. "*.foo.com"). The wildcard character '*' must appear by itself as the first DNS label and matches only a single label. You cannot have a wildcard label by itself (e.g. Host == "*"). Requests will be matched against the Host field in the following way: 1. If Host is precise, the request matches this rule if the http host header is equal to Host. 2. If Host is a wildcard, then the request matches this rule if the http host header is to equal to the suffix (removing the first label) of the wildcard rule. +string +E +http= +;#/definitions/io.k8s.api.networking.v1.HTTPIngressRuleValue + +.io.k8s.api.networking.v1.IngressServiceBackend"CIngressServiceBackend references a Kubernetes Service as a Backend.name +object +x +namep"cName is the referenced service. The service must exist in the same namespace as the Ingress object. +string + +port +9#/definitions/io.k8s.api.networking.v1.ServiceBackendPort"cPort of the referenced service. A port name or port number is required for a IngressServiceBackend. + +$io.k8s.api.networking.v1.IngressSpec";IngressSpec describes the Ingress the user wishes to exist. +object + +defaultBackend +5#/definitions/io.k8s.api.networking.v1.IngressBackend"DefaultBackend is the backend that should handle requests that don't match any rule. If Rules are not specified, DefaultBackend must be specified. If DefaultBackend is not set, the handling of requests that do not match any of the rules will be up to the Ingress controller. + +ingressClassName"IngressClassName is the name of the IngressClass cluster resource. The associated IngressClass defines which controller will implement the resource. This replaces the deprecated `kubernetes.io/ingress.class` annotation. For backwards compatibility, when that annotation is set, it must be given precedence over this field. The controller may emit a warning if the field and annotation have different values. Implementations of this API should ignore Ingresses without a class specified. An IngressClass resource may be marked as default, which can be used to set a default value for this field. For more information, refer to the IngressClass documentation. +string + +rules"A list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend. +array6 +4 +2#/definitions/io.k8s.api.networking.v1.IngressRule# +x-kubernetes-list-type atomic + + +tls"TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI. +array5 +3 +1#/definitions/io.k8s.api.networking.v1.IngressTLS# +x-kubernetes-list-type atomic + + +&io.k8s.api.networking.v1.IngressStatus"8IngressStatus describe the current state of the Ingress. +object + + loadBalanceru +3#/definitions/io.k8s.api.core.v1.LoadBalancerStatus">LoadBalancer contains the current status of the load-balancer. + +#io.k8s.api.networking.v1.IngressTLS"MIngressTLS describes the transport layer security associated with an Ingress. +object + +hosts"Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. +array +  +string# +x-kubernetes-list-type atomic + + + +secretName"SecretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the "Host" header field used by an IngressRule, the SNI host is used for termination and value of the Host header is used for routing. +string + +&io.k8s.api.networking.v1.NetworkPolicy "INetworkPolicy describes what network traffic is allowed for a set of Pods +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +specy +8#/definitions/io.k8s.api.networking.v1.NetworkPolicySpec"=Specification of the desired behavior for this NetworkPolicy. + +status +:#/definitions/io.k8s.api.networking.v1.NetworkPolicyStatus"Status is the current state of the NetworkPolicy. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-statusd +x-kubernetes-group-version-kindA?- group: networking.k8s.io + kind: NetworkPolicy + version: v1 + + +0io.k8s.api.networking.v1.NetworkPolicyEgressRule"NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 +object + +ports"List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. +array< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyPort + +to"List of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list. +array< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyPeer + +1io.k8s.api.networking.v1.NetworkPolicyIngressRule"NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from. +object + +from"List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the from list. +array< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyPeer + +ports"List of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. +array< +: +8#/definitions/io.k8s.api.networking.v1.NetworkPolicyPort + +*io.k8s.api.networking.v1.NetworkPolicyList"5NetworkPolicyList is a list of NetworkPolicy objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +r +itemsi""Items is a list of schema objects. +array8 +6 +4#/definitions/io.k8s.api.networking.v1.NetworkPolicy + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatah +x-kubernetes-group-version-kindEC- group: networking.k8s.io + kind: NetworkPolicyList + version: v1 + + + +*io.k8s.api.networking.v1.NetworkPolicyPeer "lNetworkPolicyPeer describes a peer to allow traffic to/from. Only certain combinations of fields are allowed +object + +ipBlock +.#/definitions/io.k8s.api.networking.v1.IPBlock"mIPBlock defines policy on a particular IPBlock. If this field is set then neither of the other fields can be. + +namespaceSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Selects Namespaces using cluster-scoped labels. This field follows standard label selector semantics; if present but empty, it selects all namespaces. + +If PodSelector is also set, then the NetworkPolicyPeer as a whole selects the Pods matching PodSelector in the Namespaces selected by NamespaceSelector. Otherwise it selects all Pods in the Namespaces selected by NamespaceSelector. + + podSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"This is a label selector which selects Pods. This field follows standard label selector semantics; if present but empty, it selects all pods. + +If NamespaceSelector is also set, then the NetworkPolicyPeer as a whole selects the Pods matching PodSelector in the Namespaces selected by NamespaceSelector. Otherwise it selects the Pods matching PodSelector in the policy's own Namespace. + +*io.k8s.api.networking.v1.NetworkPolicyPort"6NetworkPolicyPort describes a port to allow traffic on +object + +endPortint32"If set, indicates that the range of ports from port to endPort, inclusive, should be allowed by the policy. This field cannot be defined if the port field is not defined or if the port field is defined as a named (string) port. The endPort must be equal or greater than port. This feature is in Beta state and is enabled by default. It can be disabled using the Feature Gate "NetworkPolicyEndPort". +integer + +port +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"The port on the given protocol. This can either be a numerical or named port on a pod. If this field is not provided, this matches all port names and numbers. If present, only traffic on the specified protocol AND port will be matched. + +protocolu"hThe protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this field defaults to TCP. +string + +*io.k8s.api.networking.v1.NetworkPolicySpec"?NetworkPolicySpec provides the specification of a NetworkPolicy podSelector +object + +egress"List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 +arrayB +@ +>#/definitions/io.k8s.api.networking.v1.NetworkPolicyEgressRule + +ingress"List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod's local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default) +arrayC +A +?#/definitions/io.k8s.api.networking.v1.NetworkPolicyIngressRule + + podSelector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Selects the pods to which this NetworkPolicy object applies. The array of ingress rules is applied to any pods selected by this field. Multiple network policies can select the same set of pods. In this case, the ingress rules for each are combined additively. This field is NOT optional and follows standard label selector semantics. An empty podSelector matches all pods in this namespace. + + policyTypes"List of rule types that the NetworkPolicy relates to. Valid options are ["Ingress"], ["Egress"], or ["Ingress", "Egress"]. If this field is not specified, it will default based on the existence of Ingress or Egress rules; policies that contain an Egress section are assumed to affect Egress, and all policies (whether or not they contain an Ingress section) are assumed to affect Ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ "Egress" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include "Egress" (since such a policy would not include an Egress section and would otherwise default to just [ "Ingress" ]). This field is beta-level in 1.8 +array +  +string + +,io.k8s.api.networking.v1.NetworkPolicyStatus"DNetworkPolicyStatus describe the current state of the NetworkPolicy. +object + + +conditions"qConditions holds an array of metav1.Condition that describe the state of the NetworkPolicy. Current service state +array@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Condition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + ++io.k8s.api.networking.v1.ServiceBackendPort"8ServiceBackendPort is the service port being referenced. +object +u +namem"`Name is the name of the port on the Service. This is a mutually exclusive setting with "Number". +string + +numberint32"oNumber is the numerical port number (e.g. 80) on the Service. This is a mutually exclusive setting with "Name". +integer + +io.k8s.api.node.v1.Overhead"ROverhead structure represents the resource overhead associated with running a pod. +object + +podFixed"NPodFixed represents the fixed resource overhead associated with running a pod.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +io.k8s.api.node.v1.RuntimeClass"RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/handler +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +handler"Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable. +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"gMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +overhead +)#/definitions/io.k8s.api.node.v1.Overhead"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see + https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/ + + +scheduling ++#/definitions/io.k8s.api.node.v1.Scheduling"Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.] +x-kubernetes-group-version-kind:8- group: node.k8s.io + kind: RuntimeClass + version: v1 + + +#io.k8s.api.node.v1.RuntimeClassList"3RuntimeClassList is a list of RuntimeClass objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +k +itemsb""Items is a list of schema objects. +array1 +/ +-#/definitions/io.k8s.api.node.v1.RuntimeClass + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataa +x-kubernetes-group-version-kind><- group: node.k8s.io + kind: RuntimeClassList + version: v1 + + +io.k8s.api.node.v1.Scheduling"TScheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. +object + + nodeSelector"nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. +  +string +object" +x-kubernetes-map-type atomic + + + tolerations"tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass. +array/ +- ++#/definitions/io.k8s.api.core.v1.Toleration# +x-kubernetes-list-type atomic + + + io.k8s.api.node.v1beta1.Overhead"ROverhead structure represents the resource overhead associated with running a pod. +object + +podFixed"NPodFixed represents the fixed resource overhead associated with running a pod.? += +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity +object + +$io.k8s.api.node.v1beta1.RuntimeClass"RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are (currently) manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod. For more details, see https://git.k8s.io/enhancements/keps/sig-node/585-runtime-classhandler +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +handler"Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration. It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable. +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"gMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +overhead +.#/definitions/io.k8s.api.node.v1beta1.Overhead"Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md + + +scheduling +0#/definitions/io.k8s.api.node.v1beta1.Scheduling"Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.b +x-kubernetes-group-version-kind?=- group: node.k8s.io + kind: RuntimeClass + version: v1beta1 + + +(io.k8s.api.node.v1beta1.RuntimeClassList"3RuntimeClassList is a list of RuntimeClass objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +p +itemsg""Items is a list of schema objects. +array6 +4 +2#/definitions/io.k8s.api.node.v1beta1.RuntimeClass + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataf +x-kubernetes-group-version-kindCA- group: node.k8s.io + kind: RuntimeClassList + version: v1beta1 + + +"io.k8s.api.node.v1beta1.Scheduling"TScheduling specifies the scheduling constraints for nodes supporting a RuntimeClass. +object + + nodeSelector"nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission. +  +string +object" +x-kubernetes-map-type atomic + + + tolerations"tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass. +array/ +- ++#/definitions/io.k8s.api.core.v1.Toleration# +x-kubernetes-list-type atomic + + +io.k8s.api.policy.v1.Eviction "Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +r + deleteOptionsa +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions"DeleteOptions may be provided + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadatat +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"3ObjectMeta describes the pod that is being evicted.T +x-kubernetes-group-version-kind1/- group: policy + kind: Eviction + version: v1 + + + +(io.k8s.api.policy.v1.PodDisruptionBudget +"hPodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +:#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetSpec"ASpecification of the desired behavior of the PodDisruptionBudget. + +statusy +<#/definitions/io.k8s.api.policy.v1.PodDisruptionBudgetStatus"9Most recently observed status of the PodDisruptionBudget._ +x-kubernetes-group-version-kind<:- group: policy + kind: PodDisruptionBudget + version: v1 + + +,io.k8s.api.policy.v1.PodDisruptionBudgetList "@PodDisruptionBudgetList is a collection of PodDisruptionBudgets.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +y +itemsp"'Items is a list of PodDisruptionBudgets +array: +8 +6#/definitions/io.k8s.api.policy.v1.PodDisruptionBudget + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatac +x-kubernetes-group-version-kind@>- group: policy + kind: PodDisruptionBudgetList + version: v1 + + +,io.k8s.api.policy.v1.PodDisruptionBudgetSpec"BPodDisruptionBudgetSpec is a description of a PodDisruptionBudget. +object + +maxUnavailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". + + minAvailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"An eviction is allowed if at least "minAvailable" pods selected by "selector" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying "100%". + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Label query over pods whose evictions are managed by the disruption budget. A null selector will match no pods, while an empty ({}) selector will select all pods within the namespace.) +x-kubernetes-patch-strategy +replace + + +.io.k8s.api.policy.v1.PodDisruptionBudgetStatus"PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.disruptionsAllowedcurrentHealthydesiredHealthy expectedPods +object + + +conditions"Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute + the number of allowed disruptions. Therefore no disruptions are + allowed and the status of the condition will be False. +- InsufficientPods: The number of pods are either at or below the number + required by the PodDisruptionBudget. No disruptions are + allowed and the status of the condition will be False. +- SufficientPods: There are more pods than required by the PodDisruptionBudget. + The condition will be True, and the number of allowed + disruptions are provided by the disruptionsAllowed property. +array@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Condition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + +E +currentHealthy3int32"current number of healthy pods +integer +M +desiredHealthy;int32"&minimum desired number of healthy pods +integer + + disruptedPods"DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions.; +9 +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time +object +` +disruptionsAllowedJint32"5Number of pod disruptions that are currently allowed. +integer +[ + expectedPodsKint32"6total number of pods counted by this disruption budget +integer + +observedGenerationint64"Most recent generation observed when updating this PDB status. DisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation. +integer + +*io.k8s.api.policy.v1beta1.AllowedCSIDriver"RAllowedCSIDriver represents a single inline CSI Driver that is allowed to be used.name +objectD +B +name:"-Name is the registered name of the CSI driver +string + ++io.k8s.api.policy.v1beta1.AllowedFlexVolume"LAllowedFlexVolume represents a single Flexvolume that is allowed to be used.driver +objectE +C +driver9",driver is the name of the Flexvolume driver. +string + +)io.k8s.api.policy.v1beta1.AllowedHostPath"AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. +object + + +pathPrefix"pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. + +Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` +string + +readOnlyw"iwhen set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly. +boolean + +0io.k8s.api.policy.v1beta1.FSGroupStrategyOptions"YFSGroupStrategyOptions defines the strategy type and options used to create the strategy. +object + +ranges"ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. +array3 +1 +/#/definitions/io.k8s.api.policy.v1beta1.IDRange +h +rule`"Srule is the strategy that will dictate what FSGroup is used in the SecurityContext. +string + +'io.k8s.api.policy.v1beta1.HostPortRange"HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined.minmax +object +C +max<int32"'max is the end of the range, inclusive. +integer +E +min>int32")min is the start of the range, inclusive. +integer + +!io.k8s.api.policy.v1beta1.IDRange"6IDRange provides a min/max of an allowed range of IDs.minmax +object +C +max<int64"'max is the end of the range, inclusive. +integer +E +min>int64")min is the start of the range, inclusive. +integer + + +-io.k8s.api.policy.v1beta1.PodDisruptionBudget +"hPodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +?#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec"ASpecification of the desired behavior of the PodDisruptionBudget. + +status~ +A#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus"9Most recently observed status of the PodDisruptionBudget.d +x-kubernetes-group-version-kindA?- group: policy + kind: PodDisruptionBudget + version: v1beta1 + + +1io.k8s.api.policy.v1beta1.PodDisruptionBudgetList "@PodDisruptionBudgetList is a collection of PodDisruptionBudgets.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"1items list individual PodDisruptionBudget objects +array? += +;#/definitions/io.k8s.api.policy.v1beta1.PodDisruptionBudget + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatah +x-kubernetes-group-version-kindEC- group: policy + kind: PodDisruptionBudgetList + version: v1beta1 + + +1io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec "BPodDisruptionBudgetSpec is a description of a PodDisruptionBudget. +object + +maxUnavailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"An eviction is allowed if at most "maxUnavailable" pods selected by "selector" are unavailable after the eviction, i.e. even in absence of the evicted pod. For example, one can prevent all voluntary evictions by specifying 0. This is a mutually exclusive setting with "minAvailable". + + minAvailable +=#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString"An eviction is allowed if at least "minAvailable" pods selected by "selector" will still be available after the eviction, i.e. even in the absence of the evicted pod. So for example you can prevent all voluntary evictions by specifying "100%". + +selector +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"Label query over pods whose evictions are managed by the disruption budget. A null selector selects no pods. An empty selector ({}) also selects no pods, which differs from standard behavior of selecting all pods. In policy/v1, an empty selector will select all pods in the namespace. + +3io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus"PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system.disruptionsAllowedcurrentHealthydesiredHealthy expectedPods +object + + +conditions"Conditions contain conditions for PDB. The disruption controller sets the DisruptionAllowed condition. The following are known values for the reason field (additional reasons could be added in the future): - SyncFailed: The controller encountered an error and wasn't able to compute + the number of allowed disruptions. Therefore no disruptions are + allowed and the status of the condition will be False. +- InsufficientPods: The number of pods are either at or below the number + required by the PodDisruptionBudget. No disruptions are + allowed and the status of the condition will be False. +- SufficientPods: There are more pods than required by the PodDisruptionBudget. + The condition will be True, and the number of allowed + disruptions are provided by the disruptionsAllowed property. +array@ +> +<#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Condition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + +E +currentHealthy3int32"current number of healthy pods +integer +M +desiredHealthy;int32"&minimum desired number of healthy pods +integer + + disruptedPods"DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn't occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions.; +9 +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time +object +` +disruptionsAllowedJint32"5Number of pod disruptions that are currently allowed. +integer +[ + expectedPodsKint32"6total number of pods counted by this disruption budget +integer + +observedGenerationint64"Most recent generation observed when updating this PDB status. DisruptionsAllowed and other status information is valid only if observedGeneration equals to PDB's object generation. +integer + ++io.k8s.api.policy.v1beta1.PodSecurityPolicy "PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated in 1.21. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +j +specb +=#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicySpec"!spec defines the policy enforced.b +x-kubernetes-group-version-kind?=- group: policy + kind: PodSecurityPolicy + version: v1beta1 + + +/io.k8s.api.policy.v1beta1.PodSecurityPolicyList "=PodSecurityPolicyList is a list of PodSecurityPolicy objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +w +itemsn""items is a list of schema objects. +array= +; +9#/definitions/io.k8s.api.policy.v1beta1.PodSecurityPolicy + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataf +x-kubernetes-group-version-kindCA- group: policy + kind: PodSecurityPolicyList + version: v1beta1 + +. +/io.k8s.api.policy.v1beta1.PodSecurityPolicySpec."2PodSecurityPolicySpec defines the policy enforced.seLinux runAsUsersupplementalGroupsfsGroup +object- + +allowPrivilegeEscalation"yallowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. +boolean + +allowedCSIDrivers"AllowedCSIDrivers is an allowlist of inline CSI drivers that must be explicitly set to be embedded within a pod spec. An empty value indicates that any CSI driver can be used for inline ephemeral volumes. This is a beta field, and is only honored if the API server enables the CSIInlineVolume feature gate. +array< +: +8#/definitions/io.k8s.api.policy.v1beta1.AllowedCSIDriver + +allowedCapabilities"allowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field may be added at the pod author's discretion. You must not list a capability in both allowedCapabilities and requiredDropCapabilities. +array +  +string + +allowedFlexVolumes"allowedFlexVolumes is an allowlist of Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the "volumes" field. +array= +; +9#/definitions/io.k8s.api.policy.v1beta1.AllowedFlexVolume + +allowedHostPaths"`allowedHostPaths is an allowlist of host paths. Empty indicates that all host paths may be used. +array; +9 +7#/definitions/io.k8s.api.policy.v1beta1.AllowedHostPath + +allowedProcMountTypes"AllowedProcMountTypes is an allowlist of allowed ProcMountTypes. Empty or nil indicates that only the DefaultProcMountType may be used. This requires the ProcMountType feature flag to be enabled. +array +  +string + +allowedUnsafeSysctls"allowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in "*" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to allowlist all allowed unsafe sysctls explicitly to avoid rejection. + +Examples: e.g. "foo/*" allows "foo/bar", "foo/baz", etc. e.g. "foo.*" allows "foo.bar", "foo.baz", etc. +array +  +string + +defaultAddCapabilities"defaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capability in both defaultAddCapabilities and requiredDropCapabilities. Capabilities added here are implicitly allowed, and need not be included in the allowedCapabilities list. +array +  +string + +defaultAllowPrivilegeEscalation"defaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. +boolean + +forbiddenSysctls"forbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in "*" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. + +Examples: e.g. "foo/*" forbids "foo/bar", "foo/baz", etc. e.g. "foo.*" forbids "foo.bar", "foo.baz", etc. +array +  +string + +fsGroup +>#/definitions/io.k8s.api.policy.v1beta1.FSGroupStrategyOptions"WfsGroup is the strategy that will dictate what fs group is used by the SecurityContext. +d +hostIPCY"KhostIPC determines if the policy allows the use of HostIPC in the pod spec. +boolean +p + hostNetworka"ShostNetwork determines if the policy allows the use of HostNetwork in the pod spec. +boolean +d +hostPIDY"KhostPID determines if the policy allows the use of HostPID in the pod spec. +boolean + + hostPorts"FhostPorts determines which host port ranges are allowed to be exposed. +array9 +7 +5#/definitions/io.k8s.api.policy.v1beta1.HostPortRange +_ + +privilegedQ"Cprivileged determines if a pod can request to be run as privileged. +boolean + +readOnlyRootFilesystem"readOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the PSP should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. +boolean + +requiredDropCapabilities"requiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. +array +  +string + + +runAsGroup +A#/definitions/io.k8s.api.policy.v1beta1.RunAsGroupStrategyOptions"RunAsGroup is the strategy that will dictate the allowable RunAsGroup values that may be set. If this field is omitted, the pod's RunAsGroup can take any value. This field requires the RunAsGroup feature gate to be enabled. + + runAsUser +@#/definitions/io.k8s.api.policy.v1beta1.RunAsUserStrategyOptions"[runAsUser is the strategy that will dictate the allowable RunAsUser values that may be set. + + runtimeClass +C#/definitions/io.k8s.api.policy.v1beta1.RuntimeClassStrategyOptions"runtimeClass is the strategy that will dictate the allowable RuntimeClasses for a pod. If this field is omitted, the pod's runtimeClassName field is unrestricted. Enforcement of this field depends on the RuntimeClass feature gate being enabled. + +seLinux +>#/definitions/io.k8s.api.policy.v1beta1.SELinuxStrategyOptions"OseLinux is the strategy that will dictate the allowable labels that may be set. + +supplementalGroups +I#/definitions/io.k8s.api.policy.v1beta1.SupplementalGroupsStrategyOptions"nsupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext. + +volumes"}volumes is an allowlist of volume plugins. Empty indicates that no volumes may be used. To allow all volumes you may use '*'. +array +  +string + +3io.k8s.api.policy.v1beta1.RunAsGroupStrategyOptions"`RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy.rule +object + +ranges"ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs. +array3 +1 +/#/definitions/io.k8s.api.policy.v1beta1.IDRange +l +ruled"Wrule is the strategy that will dictate the allowable RunAsGroup values that may be set. +string + +2io.k8s.api.policy.v1beta1.RunAsUserStrategyOptions"_RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy.rule +object + +ranges"ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. +array3 +1 +/#/definitions/io.k8s.api.policy.v1beta1.IDRange +k +rulec"Vrule is the strategy that will dictate the allowable RunAsUser values that may be set. +string + +5io.k8s.api.policy.v1beta1.RuntimeClassStrategyOptions"iRuntimeClassStrategyOptions define the strategy that will dictate the allowable RuntimeClasses for a pod.allowedRuntimeClassNames +object + +allowedRuntimeClassNames"allowedRuntimeClassNames is an allowlist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset. +array +  +string + +defaultRuntimeClassName"defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod. +string + +0io.k8s.api.policy.v1beta1.SELinuxStrategyOptions"]SELinuxStrategyOptions defines the strategy type and any options used to create the strategy.rule +object +a +ruleY"Lrule is the strategy that will dictate the allowable labels that may be set. +string + +seLinuxOptions +/#/definitions/io.k8s.api.core.v1.SELinuxOptions"seLinuxOptions required to run as; required for MustRunAs More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/ + +;io.k8s.api.policy.v1beta1.SupplementalGroupsStrategyOptions"dSupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. +object + +ranges"ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. +array3 +1 +/#/definitions/io.k8s.api.policy.v1beta1.IDRange +t +rulel"_rule is the strategy that will dictate what supplemental groups is used in the SecurityContext. +string + +"io.k8s.api.rbac.v1.AggregationRule"VAggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole +object + +clusterRoleSelectors"ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole's permissions will be added +arrayD +B +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + +io.k8s.api.rbac.v1.ClusterRole "ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. +object + +aggregationRule +0#/definitions/io.k8s.api.rbac.v1.AggregationRule"AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller. + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. +{ +rulesr"4Rules holds all the PolicyRules for this ClusterRole +array/ +- ++#/definitions/io.k8s.api.rbac.v1.PolicyRulej +x-kubernetes-group-version-kindGE- group: rbac.authorization.k8s.io + kind: ClusterRole + version: v1 + + +%io.k8s.api.rbac.v1.ClusterRoleBinding +"ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.roleRef +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. + +roleRef +(#/definitions/io.k8s.api.rbac.v1.RoleRef"RoleRef can only reference a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error. + +subjectsx"=Subjects holds references to the objects the role applies to. +array, +* +(#/definitions/io.k8s.api.rbac.v1.Subjectq +x-kubernetes-group-version-kindNL- group: rbac.authorization.k8s.io + kind: ClusterRoleBinding + version: v1 + + +)io.k8s.api.rbac.v1.ClusterRoleBindingList"=ClusterRoleBindingList is a collection of ClusterRoleBindingsitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +u +itemsl"&Items is a list of ClusterRoleBindings +array7 +5 +3#/definitions/io.k8s.api.rbac.v1.ClusterRoleBinding + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +f +metadataZ +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata.u +x-kubernetes-group-version-kindRP- group: rbac.authorization.k8s.io + kind: ClusterRoleBindingList + version: v1 + + +"io.k8s.api.rbac.v1.ClusterRoleList"/ClusterRoleList is a collection of ClusterRolesitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +g +items^"Items is a list of ClusterRoles +array0 +. +,#/definitions/io.k8s.api.rbac.v1.ClusterRole + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +f +metadataZ +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata.n +x-kubernetes-group-version-kindKI- group: rbac.authorization.k8s.io + kind: ClusterRoleList + version: v1 + + + +io.k8s.api.rbac.v1.PolicyRule +"PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to.verbs +object + + apiGroups"APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. +array +  +string + +nonResourceURLs"NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as "pods" or "secrets") or non-resource URL paths (such as "/api"), but not both. +array +  +string + + resourceNames"zResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. +array +  +string +} + resourcesp"TResources is a list of resources this rule applies to. '*' represents all resources. +array +  +string + +verbs"nVerbs is a list of Verbs that apply to ALL the ResourceKinds contained in this rule. '*' represents all verbs. +array +  +string + +io.k8s.api.rbac.v1.Role"hRole is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. +t +rulesk"-Rules holds all the PolicyRules for this Role +array/ +- ++#/definitions/io.k8s.api.rbac.v1.PolicyRulec +x-kubernetes-group-version-kind@>- group: rbac.authorization.k8s.io + kind: Role + version: v1 + + +io.k8s.api.rbac.v1.RoleBinding "RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace.roleRef +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +h +metadata\ +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. + +roleRef +(#/definitions/io.k8s.api.rbac.v1.RoleRef"RoleRef can reference a Role in the current namespace or a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error. + +subjectsx"=Subjects holds references to the objects the role applies to. +array, +* +(#/definitions/io.k8s.api.rbac.v1.Subjectj +x-kubernetes-group-version-kindGE- group: rbac.authorization.k8s.io + kind: RoleBinding + version: v1 + + +"io.k8s.api.rbac.v1.RoleBindingList"/RoleBindingList is a collection of RoleBindingsitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +g +items^"Items is a list of RoleBindings +array0 +. +,#/definitions/io.k8s.api.rbac.v1.RoleBinding + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +f +metadataZ +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata.n +x-kubernetes-group-version-kindKI- group: rbac.authorization.k8s.io + kind: RoleBindingList + version: v1 + + +io.k8s.api.rbac.v1.RoleList"!RoleList is a collection of Rolesitems +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +Y +itemsP"Items is a list of Roles +array) +' +%#/definitions/io.k8s.api.rbac.v1.Role + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +f +metadataZ +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata.g +x-kubernetes-group-version-kindDB- group: rbac.authorization.k8s.io + kind: RoleList + version: v1 + + +io.k8s.api.rbac.v1.RoleRef"?RoleRef contains information that points to the role being usedapiGroupkindname +object +P +apiGroupD"7APIGroup is the group for the resource being referenced +string +B +kind:"-Kind is the type of resource being referenced +string +B +name:"-Name is the name of resource being referenced +string" +x-kubernetes-map-type atomic + + +io.k8s.api.rbac.v1.Subject"Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names.kindname +object + +apiGroup"APIGroup holds the API group of the referenced subject. Defaults to "" for ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User and Group subjects. +string + +kind"Kind of object being referenced. Values defined by this API group are "User", "Group", and "ServiceAccount". If the Authorizer does not recognized the kind value, the Authorizer should report an error. +string +9 +name1"$Name of the object being referenced. +string + + namespace"Namespace of the referenced object. If the object kind is non-namespace, such as "User" or "Group", and this value is not empty the Authorizer should report an error. +string" +x-kubernetes-map-type atomic + + +&io.k8s.api.scheduling.v1.PriorityClass"{PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.value +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + description|"odescription is an arbitrary string that usually provides guidelines on when this priority class should be used. +string + + globalDefault"globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority. +boolean + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +preemptionPolicy"PreemptionPolicy is the Policy for preempting pods with lower priority. One of Never, PreemptLowerPriority. Defaults to PreemptLowerPriority if unset. +string + +valueint32"The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec. +integerd +x-kubernetes-group-version-kindA?- group: scheduling.k8s.io + kind: PriorityClass + version: v1 + + +*io.k8s.api.scheduling.v1.PriorityClassList"6PriorityClassList is a collection of priority classes.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +t +itemsk"$items is the list of PriorityClasses +array8 +6 +4#/definitions/io.k8s.api.scheduling.v1.PriorityClass + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatah +x-kubernetes-group-version-kindEC- group: scheduling.k8s.io + kind: PriorityClassList + version: v1 + + +io.k8s.api.storage.v1.CSIDriver "CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object metadata. metadata.Name indicates the name of the CSI driver that this object refers to; it MUST be the same name returned by the CSI GetPluginName() call for that driver. The driver name must be 63 characters or less, beginning and ending with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), dots (.), and alphanumerics between. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +] +specU +1#/definitions/io.k8s.api.storage.v1.CSIDriverSpec" Specification of the CSI Driver.] +x-kubernetes-group-version-kind:8- group: storage.k8s.io + kind: CSIDriver + version: v1 + + +#io.k8s.api.storage.v1.CSIDriverList"3CSIDriverList is a collection of CSIDriver objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +g +items^"items is the list of CSIDriver +array1 +/ +-#/definitions/io.k8s.api.storage.v1.CSIDriver + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataa +x-kubernetes-group-version-kind><- group: storage.k8s.io + kind: CSIDriverList + version: v1 + ++ +#io.k8s.api.storage.v1.CSIDriverSpec+"2CSIDriverSpec is the specification of a CSIDriver. +object* + +attachRequired"attachRequired indicates this CSI volume driver requires an attach operation (because it implements the CSI ControllerPublishVolume() method), and that the Kubernetes attach detach controller should call the attach volume interface which checks the volumeattachment status and waits until the volume is attached before proceeding to mounting. The CSI external-attacher coordinates with CSI volume driver and updates the volumeattachment status when the attach operation is complete. If the CSIDriverRegistry feature gate is enabled and the value is specified to false, the attach operation will be skipped. Otherwise the attach operation will be called. + +This field is immutable. +boolean + + fsGroupPolicy"Defines if the underlying volume supports changing ownership and permission of the volume before being mounted. Refer to the specific FSGroupPolicy values for additional details. + +This field is immutable. + +Defaults to ReadWriteOnceWithFSType, which will examine each volume to determine if Kubernetes should modify ownership and permissions of the volume. With the default policy the defined fsGroup will only be applied if a fstype is defined and the volume's access mode contains ReadWriteOnce. +string + +podInfoOnMount " If set to true, podInfoOnMount indicates this CSI volume driver requires additional pod information (like podName, podUID, etc.) during mount operations. If set to false, pod information will not be passed on mount. Default is false. The CSI driver specifies podInfoOnMount as part of driver deployment. If true, Kubelet will pass pod information as VolumeContext in the CSI NodePublishVolume() calls. The CSI driver is responsible for parsing and validating the information passed in as VolumeContext. The following VolumeConext will be passed if podInfoOnMount is set to true. This list might grow, but the prefix will be used. "csi.storage.k8s.io/pod.name": pod.Name "csi.storage.k8s.io/pod.namespace": pod.Namespace "csi.storage.k8s.io/pod.uid": string(pod.UID) "csi.storage.k8s.io/ephemeral": "true" if the volume is an ephemeral inline volume + defined by a CSIVolumeSource, otherwise "false" + +"csi.storage.k8s.io/ephemeral" is a new feature in Kubernetes 1.16. It is only required for drivers which support both the "Persistent" and "Ephemeral" VolumeLifecycleMode. Other drivers can leave pod info disabled and/or ignore this field. As Kubernetes 1.15 doesn't support this field, drivers can only support one mode when deployed on such a cluster and the deployment determines which mode that is, for example via a command line parameter of the driver. + +This field is immutable. +boolean + +requiresRepublish"RequiresRepublish indicates the CSI driver wants `NodePublishVolume` being periodically called to reflect any possible change in the mounted volume. This field defaults to false. + +Note: After a successful initial NodePublishVolume call, subsequent calls to NodePublishVolume should only update the contents of the volume. New mount points will not be seen by a running container. +boolean + +storageCapacity"If set to true, storageCapacity indicates that the CSI volume driver wants pod scheduling to consider the storage capacity that the driver deployment will report by creating CSIStorageCapacity objects with capacity information. + +The check can be enabled immediately when deploying a driver. In that case, provisioning new volumes with late binding will pause until the driver deployment has published some suitable CSIStorageCapacity object. + +Alternatively, the driver can be deployed with the field unset or false and it can be flipped later when storage capacity information has been published. + +This field was immutable in Kubernetes <= 1.22 and now is mutable. +boolean + + tokenRequests"TokenRequests indicates the CSI driver needs pods' service account tokens it is mounting volume for to do necessary authentication. Kubelet will pass the tokens in VolumeContext in the CSI NodePublishVolume calls. The CSI driver should parse and validate the following VolumeContext: "csi.storage.k8s.io/serviceAccount.tokens": { + "": { + "token": , + "expirationTimestamp": , + }, + ... +} + +Note: Audience in each TokenRequest should be different and at most one token is empty string. To receive a new token after expiry, RequiresRepublish can be used to trigger NodePublishVolume periodically. +array4 +2 +0#/definitions/io.k8s.api.storage.v1.TokenRequest# +x-kubernetes-list-type atomic + + +volumeLifecycleModes"volumeLifecycleModes defines what kind of volumes this CSI volume driver supports. The default if the list is empty is "Persistent", which is the usage defined by the CSI specification and implemented in Kubernetes via the usual PV/PVC mechanism. The other mode is "Ephemeral". In this mode, volumes are defined inline inside the pod spec with CSIVolumeSource and their lifecycle is tied to the lifecycle of that pod. A driver has to be aware of this because it is only going to get a NodePublishVolume call for such a volume. For more information about implementing this mode, see https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html A driver can support one or more of these modes and more modes may be added in the future. This field is beta. + +This field is immutable. +array +  +string +x-kubernetes-list-typeset + + +io.k8s.api.storage.v1.CSINode "CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn't create this object. CSINode has an OwnerReference that points to the corresponding node object.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +| +metadatap +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"/metadata.name must be the Kubernetes node name. +_ +specW +/#/definitions/io.k8s.api.storage.v1.CSINodeSpec"$spec is the specification of CSINode[ +x-kubernetes-group-version-kind86- group: storage.k8s.io + kind: CSINode + version: v1 + + +#io.k8s.api.storage.v1.CSINodeDriver "]CSINodeDriver holds information about the specification of one CSI driver installed on a nodenamenodeID +object + + allocatable +7#/definitions/io.k8s.api.storage.v1.VolumeNodeResources"lallocatable represents the volume resources of a node that are available for scheduling. This field is beta. + +name"This is the name of the CSI driver that this object refers to. This MUST be the same name returned by the CSI GetPluginName() call for that driver. +string + +nodeID"nodeID of the node from the driver point of view. This field enables Kubernetes to communicate with storage systems that do not share the same nomenclature for nodes. For example, Kubernetes may refer to a given node as "node1", but the storage system may refer to the same node as "nodeA". When Kubernetes issues a command to the storage system to attach a volume to a specific node, it can use this field to refer to the node name using the ID that the storage system will understand, e.g. "nodeA" instead of "node1". This field is required. +string + + topologyKeys"topologyKeys is the list of keys supported by the driver. When a driver is initialized on a cluster, it provides a set of topology keys that it understands (e.g. "company.com/zone", "company.com/region"). When a driver is initialized on a node, it provides the same topology keys along with values. Kubelet will expose these topology keys as labels on its own node object. When Kubernetes does topology aware provisioning, it can use this list to determine which labels it should retrieve from the node object and pass back to the driver. It is possible for different nodes to use different topology keys. This can be empty if driver does not support topology. +array +  +string + +!io.k8s.api.storage.v1.CSINodeList"/CSINodeList is a collection of CSINode objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +c +itemsZ"items is the list of CSINode +array/ +- ++#/definitions/io.k8s.api.storage.v1.CSINode + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata_ +x-kubernetes-group-version-kind<:- group: storage.k8s.io + kind: CSINodeList + version: v1 + + +!io.k8s.api.storage.v1.CSINodeSpec"\CSINodeSpec holds information about the specification of all CSI drivers installed on a nodedrivers +object + +drivers"drivers is a list of information of all CSI Drivers existing on a node. If all drivers in the list are uninstalled, this can become empty. +array5 +3 +1#/definitions/io.k8s.api.storage.v1.CSINodeDriver' +x-kubernetes-patch-merge-keyname +' +x-kubernetes-patch-strategymerge + +! +(io.k8s.api.storage.v1.CSIStorageCapacity!" CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. + +For example this can express things like: - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1" - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123" + +The following three cases all imply that no capacity is available for a certain combination: - no object exists with suitable topology and storage class name - such an object exists, but the capacity is unset - such an object exists, but the capacity is zero + +The producer of these objects can decide which approach is more suitable. + +They are consumed by the kube-scheduler when a CSI driver opts into capacity-aware scheduling with CSIDriverSpec.StorageCapacity. The scheduler compares the MaximumVolumeSize against the requested size of pending volumes to filter out unsuitable nodes. If MaximumVolumeSize is unset, it falls back to a comparison against the less precise Capacity. If that is also unset, the scheduler assumes that capacity is insufficient and tries some other node.storageClassName +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +capacity +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"Capacity is the value reported by the CSI driver in its GetCapacityResponse for a GetCapacityRequest with topology and parameters that match the previous fields. + +The semantic is currently (CSI spec 1.2) defined as: The available capacity, in bytes, of the storage that can be used to provision volumes. If not set, that information is currently unavailable. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +maximumVolumeSize +;#/definitions/io.k8s.apimachinery.pkg.api.resource.Quantity"MaximumVolumeSize is the value reported by the CSI driver in its GetCapacityResponse for a GetCapacityRequest with topology and parameters that match the previous fields. + +This is defined since CSI spec 1.4.0 as the largest size that may be used in a CreateVolumeRequest.capacity_range.required_bytes field to create a volume with the same parameters as those in GetCapacityRequest. The corresponding value in the Kubernetes API is ResourceRequirements.Requests in a volume claim. + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. The name has no particular meaning. It must be be a DNS subdomain (dots allowed, 253 characters). To ensure that there are no conflicts with other CSI drivers on the cluster, the recommendation is to use csisc-, a generated name, or a reverse-domain name which ends with the unique CSI driver name. + +Objects are namespaced. + +More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + nodeTopology +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"NodeTopology defines which nodes have access to the storage for which capacity was reported. If not set, the storage is not accessible from any node in the cluster. If empty, the storage is accessible from all nodes. This field is immutable. + +storageClassName"The name of the StorageClass that the reported capacity applies to. It must meet the same requirements as the name of a StorageClass object (non-empty, DNS subdomain). If that object no longer exists, the CSIStorageCapacity object is obsolete and should be removed by its creator. This field is immutable. +stringf +x-kubernetes-group-version-kindCA- group: storage.k8s.io + kind: CSIStorageCapacity + version: v1 + + + +,io.k8s.api.storage.v1.CSIStorageCapacityList "ECSIStorageCapacityList is a collection of CSIStorageCapacity objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"0Items is the list of CSIStorageCapacity objects. +array: +8 +6#/definitions/io.k8s.api.storage.v1.CSIStorageCapacity' +x-kubernetes-list-map-keys - name + +x-kubernetes-list-typemap + + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataj +x-kubernetes-group-version-kindGE- group: storage.k8s.io + kind: CSIStorageCapacityList + version: v1 + + +"io.k8s.api.storage.v1.StorageClass"StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. + +StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. provisioner +object +n +allowVolumeExpansionV"HAllowVolumeExpansion shows whether the storage class allow volume expand +boolean + +allowedTopologies"Restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is only honored by servers that enable the VolumeScheduling feature. +array9 +7 +5#/definitions/io.k8s.api.core.v1.TopologySelectorTerm# +x-kubernetes-list-type atomic + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + mountOptions"Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. ["ro", "soft"]. Not validated - mount of the PVs will simply fail if one is invalid. +array +  +string + + +parameters"eParameters holds the parameters for the provisioner that should create volumes of this storage class. +  +string +object +N + provisioner?"2Provisioner indicates the type of the provisioner. +string + + reclaimPolicy"xDynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete. +string + +volumeBindingMode"VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is only honored by servers that enable the VolumeScheduling feature. +string` +x-kubernetes-group-version-kind=;- group: storage.k8s.io + kind: StorageClass + version: v1 + + +&io.k8s.api.storage.v1.StorageClassList"4StorageClassList is a collection of storage classes.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +o +itemsf"#Items is the list of StorageClasses +array4 +2 +0#/definitions/io.k8s.api.storage.v1.StorageClass + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatad +x-kubernetes-group-version-kindA?- group: storage.k8s.io + kind: StorageClassList + version: v1 + + +"io.k8s.api.storage.v1.TokenRequest", a generated name, or a reverse-domain name which ends with the unique CSI driver name. + +Objects are namespaced. + +More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + nodeTopology +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"NodeTopology defines which nodes have access to the storage for which capacity was reported. If not set, the storage is not accessible from any node in the cluster. If empty, the storage is accessible from all nodes. This field is immutable. + +storageClassName"The name of the StorageClass that the reported capacity applies to. It must meet the same requirements as the name of a StorageClass object (non-empty, DNS subdomain). If that object no longer exists, the CSIStorageCapacity object is obsolete and should be removed by its creator. This field is immutable. +stringk +x-kubernetes-group-version-kindHF- group: storage.k8s.io + kind: CSIStorageCapacity + version: v1beta1 + + + +1io.k8s.api.storage.v1beta1.CSIStorageCapacityList "ECSIStorageCapacityList is a collection of CSIStorageCapacity objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"0Items is the list of CSIStorageCapacity objects. +array? += +;#/definitions/io.k8s.api.storage.v1beta1.CSIStorageCapacity' +x-kubernetes-list-map-keys - name + +x-kubernetes-list-typemap + + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatao +x-kubernetes-group-version-kindLJ- group: storage.k8s.io + kind: CSIStorageCapacityList + version: v1beta1 + + + +Wio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceColumnDefinition "KCustomResourceColumnDefinition specifies a column for server side printing.nametypejsonPath +object +W + descriptionH";description is a human readable description of this column. +string + +format"format is an optional OpenAPI type definition for this column. The 'name' format is applied to the primary identifier column to assist in clients identifying column is the resource name. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. +string + +jsonPath"jsonPath is a simple JSON path (i.e. with array notation) which is evaluated against each custom resource to produce the value for this column. +string +B +name:"-name is a human readable name for the column. +string + +priorityint32"priority is an integer defining the relative importance of this column compared to others. Lower numbers are considered higher priority. Columns that may be omitted in limited space scenarios should be given a priority greater than 0. +integer + +type"type is an OpenAPI type definition for this column. See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types for details. +string + +Qio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion"MCustomResourceConversion describes how to convert different versions of a CR.strategy +object + +strategy"strategy specifies how custom resources are converted between versions. Allowed values are: - `None`: The converter only change the apiVersion and would not touch any other field in the custom resource. - `Webhook`: API Server will call to an external webhook to do the conversion. Additional information + is needed for this option. This requires spec.preserveUnknownFields to be false, and spec.conversion.webhook to be set. +string + +webhook +X#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion"cwebhook describes how to call the conversion webhook. Required when `strategy` is set to `Webhook`. + +Qio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition "CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>.spec +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +c#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec"9spec describes how the user wants the resources to appear + +status +e#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus"Astatus indicates the actual state of the CustomResourceDefinitionr +x-kubernetes-group-version-kindOM- group: apiextensions.k8s.io + kind: CustomResourceDefinition + version: v1 + + +Zio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition"YCustomResourceDefinitionCondition contains details for the current condition of this pod.typestatus +object + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"SlastTransitionTime last time the condition transitioned from one status to another. +e +messageZ"Mmessage is a human-readable message indicating details about last transition. +string +j +reason`"Sreason is a unique, one-word, CamelCase reason for the condition's last transition. +string +Z +statusP"Cstatus is the status of the condition. Can be True, False, Unknown. +string +q +typei"\type is the type of the condition. Types include Established, NamesAccepted and Terminating. +string + + +Uio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionList "KCustomResourceDefinitionList is a list of CustomResourceDefinition objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"6items list individual CustomResourceDefinition objects +arrayc +a +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinition + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard object's metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadatav +x-kubernetes-group-version-kindSQ- group: apiextensions.k8s.io + kind: CustomResourceDefinitionList + version: v1 + + + +Vio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames +"XCustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinitionpluralkind +object + + +categories"categories is a list of grouped resources this custom resource belongs to (e.g. 'all'). This is published in API discovery documents, and used by clients to support invocations like `kubectl get all`. +array +  +string + +kind"kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls. +string +q +listKinde"XlistKind is the serialized kind of the list for this resource. Defaults to "`kind`List". +string + +plural"plural is the plural name of the resource to serve. The custom resources are served under `/apis///.../`. Must match the name of the CustomResourceDefinition (in the form `.`). Must be all lowercase. +string + + +shortNames"shortNames are short names for the resource, exposed in API discovery documents, and used by clients to support invocations like `kubectl get `. It must be all lowercase. +array +  +string + +singulart"gsingular is the singular name of the resource. It must be all lowercase. Defaults to lowercased `kind`. +string + +Uio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionSpec"PCustomResourceDefinitionSpec describes how a user wants their resource to appeargroupnamesscopeversions +object + + +conversion +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceConversion"3conversion defines conversion settings for the CRD. + +group"group is the API group of the defined custom resource. The custom resources are served under `/apis//...`. Must match the name of the CustomResourceDefinition (in the form `.`). +string + +names +d#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames"Bnames specify the resource and kind names for the custom resource. + +preserveUnknownFields"preserveUnknownFields indicates that object fields which are not specified in the OpenAPI schema should be preserved when persisting to storage. apiVersion, kind, metadata and known fields inside metadata are always preserved. This field is deprecated in favor of setting `x-preserve-unknown-fields` to true in `spec.versions[*].schema.openAPIV3Schema`. See https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/#pruning-versus-preserving-unknown-fields for details. +boolean + +scope"scope indicates whether the defined custom resource is cluster- or namespace-scoped. Allowed values are `Cluster` and `Namespaced`. +string + +versions"versions is the list of all API versions of the defined custom resource. Version names are used to compute the order in which served versions are listed in API discovery. If the version string is "kube-like", it will sort above non "kube-like" version strings, which are ordered lexicographically. "Kube-like" versions start with a "v", then are followed by a number (the major version), then optionally the string "alpha" or "beta" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. +arrayj +h +f#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion + +Wio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionStatus"RCustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition +object + + acceptedNames +d#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionNames"zacceptedNames are the names that are actually being used to serve discovery. They may be different than the names in spec. + + +conditions"Nconditions indicate state for particular aspects of a CustomResourceDefinition +arrayl +j +h#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap + + +storedVersions"storedVersions lists all versions of CustomResources that were ever persisted. Tracking these versions allows a migration path for stored versions in etcd. The field is mutable so a migration controller can finish a migration to another version (ensuring no old objects are left in storage), and then remove the rest of the versions from this list. Versions may not be removed from `spec.versions` while they exist in this list. +array +  +string + +Xio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceDefinitionVersion"//...` if `served` is true. +string + +schema +_#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation"pschema describes the schema used for validation, pruning, and defaulting of this version of the custom resource. +h +served^"Pserved is a flag enabling/disabling this version from being served via REST APIs +boolean + +storage"storage indicates this version should be used when persisting custom resources to storage. There must be exactly one version with storage=true. +boolean + + subresources +a#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources"Xsubresources specify what subresources this version of the defined custom resource have. + +Wio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale "^CustomResourceSubresourceScale defines how to serve the scale subresource for CustomResources.specReplicasPathstatusReplicasPath +object + +labelSelectorPath"labelSelectorPath defines the JSON path inside of a custom resource that corresponds to Scale `status.selector`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status` or `.spec`. Must be set to work with HorizontalPodAutoscaler. The field pointed by this JSON path must be a string field (not a complex selector struct) which contains a serialized label selector in string form. More info: https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions#scale-subresource If there is no value under the given path in the custom resource, the `status.selector` value in the `/scale` subresource will default to the empty string. +string + +specReplicasPath"specReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `spec.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.spec`. If there is no value under the given path in the custom resource, the `/scale` subresource will return an error on GET. +string + +statusReplicasPath"statusReplicasPath defines the JSON path inside of a custom resource that corresponds to Scale `status.replicas`. Only JSON paths without the array notation are allowed. Must be a JSON Path under `.status`. If there is no value under the given path in the custom resource, the `status.replicas` value in the `/scale` subresource will default to 0. +string + +Xio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus"CustomResourceSubresourceStatus defines how to serve the status subresource for CustomResources. Status is represented by the `.status` JSON path inside of a CustomResource. When set, * exposes a /status subresource for the custom resource * PUT requests to the /status subresource take a custom resource object, and ignore changes to anything except the status stanza * PUT/POST/PATCH requests to the custom resource ignore changes to the status stanza +object + +Sio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresources"YCustomResourceSubresources defines the status and scale subresources for CustomResources. +object + +scale +e#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale"vscale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object. + +status +f#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus"status indicates the custom resource should serve a `/status` subresource. When enabled: 1. requests to the custom resource primary endpoint ignore changes to the `status` stanza of the object. 2. requests to the custom resource `/status` subresource ignore changes to anything other than the `status` stanza of the object. + +Qio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceValidation"MCustomResourceValidation is a list of validation methods for CustomResources. +object + +openAPIV3Schema +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps"KopenAPIV3Schema is the OpenAPI v3 schema to use for validation and pruning. + +Nio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation"YExternalDocumentation allows referencing an external resource for extended documentation. +object0 + + description  +string + +url  +string + +=io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON"JSON represents any valid JSON value. These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. +C +Hio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsC"[JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). +objectB + +$ref  +string + +$schema  +string +q +additionalItems^ +\#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool +v +additionalProperties^ +\#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBool +p +allOfg +arrayZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps +p +anyOfg +arrayZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps + +default +K#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON"default is a default value for undefined object fields. Defaulting is a beta feature under the CustomResourceDefaulting feature gate. Defaulting requires spec.preserveUnknownFields to be false. +w + definitionshZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps +object + + dependenciesug +e +c#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArray +object + + description  +string +d +enum\ +arrayO +M +K#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON +X +exampleM +K#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSON + +exclusiveMaximum  +boolean + +exclusiveMinimum  +boolean +n + externalDocs^ +\#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ExternalDocumentation + +format"format is an OpenAPI v3 format string. Unknown formats are ignored. The following formats are validated: + +- bsonobjectid: a bson object ID, i.e. a 24 characters hex string - uri: an URI as parsed by Golang net/url.ParseRequestURI - email: an email address as parsed by Golang net/mail.ParseAddress - hostname: a valid representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034]. - ipv4: an IPv4 IP as parsed by Golang net.ParseIP - ipv6: an IPv6 IP as parsed by Golang net.ParseIP - cidr: a CIDR as parsed by Golang net.ParseCIDR - mac: a MAC address as parsed by Golang net.ParseMAC - uuid: an UUID that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid3: an UUID3 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$ - uuid4: an UUID4 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - uuid5: an UUID5 that allows uppercase defined by the regex (?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$ - isbn: an ISBN10 or ISBN13 number string like "0321751043" or "978-0321751041" - isbn10: an ISBN10 number string like "0321751043" - isbn13: an ISBN13 number string like "978-0321751041" - creditcard: a credit card number defined by the regex ^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$ with any non digit characters mixed in - ssn: a U.S. social security number following the regex ^\d{3}[- ]?\d{2}[- ]?\d{4}$ - hexcolor: an hexadecimal color code like "#FFFFFF: following the regex ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ - rgbcolor: an RGB color code like rgb like "rgb(255,255,2559" - byte: base64 encoded binary data - password: any kind of string - date: a date string like "2006-01-02" as defined by full-date in RFC3339 - duration: a duration string like "22 ns" as parsed by Golang time.ParseDuration or compatible with Scala duration format - datetime: a date time string like "2014-12-15T19:30:20.000Z" as defined by date-time in RFC3339. +string + +id  +string +h +items_ +]#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray + +maxItemsint64 +integer + + maxLengthint64 +integer +$ + maxPropertiesint64 +integer + +maximumdouble +number + +minItemsint64 +integer + + minLengthint64 +integer +$ + minPropertiesint64 +integer + +minimumdouble +number +! + +multipleOfdouble +number +_ +notX +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps + +nullable  +boolean +p +oneOfg +arrayZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps + +pattern  +string +} +patternPropertieshZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps +object +v + +propertieshZ +X +V#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps +object +& +required +array +  +string + +title  +string + +type  +string + + uniqueItems  +boolean + +x-kubernetes-embedded-resource"x-kubernetes-embedded-resource defines that the value is an embedded Kubernetes runtime.Object, with TypeMeta and ObjectMeta. The type must be object. It is allowed to further restrict the embedded object. kind, apiVersion and metadata are validated automatically. x-kubernetes-preserve-unknown-fields is allowed to be true, but does not have to be if the object is fully specified (up to kind, apiVersion, metadata). +boolean + +x-kubernetes-int-or-string"x-kubernetes-int-or-string specifies that this value is either an integer or a string. If this is true, an empty type is allowed and type as child of anyOf is permitted if following one of the following patterns: + +1) anyOf: + - type: integer + - type: string +2) allOf: + - anyOf: + - type: integer + - type: string + - ... zero or more +boolean + +x-kubernetes-list-map-keys"x-kubernetes-list-map-keys annotates an array with the x-kubernetes-list-type `map` by specifying the keys used as the index of the map. + +This tag MUST only be used on lists that have the "x-kubernetes-list-type" extension set to "map". Also, the values specified for this attribute must be a scalar typed field of the child structure (no nesting is supported). + +The properties specified must either be required or have a default value, to ensure those properties are present for all list items. +array +  +string + +x-kubernetes-list-type"x-kubernetes-list-type annotates an array to further describe its topology. This extension must only be used on lists and may have 3 possible values: + +1) `atomic`: the list is treated as a single entity, like a scalar. + Atomic lists will be entirely replaced when updated. This extension + may be used on any type of list (struct, scalar, ...). +2) `set`: + Sets are lists that must not have multiple items with the same value. Each + value must be a scalar, an object with x-kubernetes-map-type `atomic` or an + array with x-kubernetes-list-type `atomic`. +3) `map`: + These lists are like maps in that their elements have a non-index key + used to identify them. Order is preserved upon merge. The map tag + must only be used on a list with elements of type object. +Defaults to atomic for arrays. +string + +x-kubernetes-map-type"x-kubernetes-map-type annotates an object to further describe its topology. This extension must only be used when type is object and may have 2 possible values: + +1) `granular`: + These maps are actual maps (key-value pairs) and each fields are independent + from each other (they can each be manipulated by separate actors). This is + the default behaviour for all maps. +2) `atomic`: the list is treated as a single entity, like a scalar. + Atomic maps will be entirely replaced when updated. +string + +$x-kubernetes-preserve-unknown-fields"x-kubernetes-preserve-unknown-fields stops the API server decoding step from pruning fields which are not specified in the validation schema. This affects fields recursively, but switches back to normal pruning behaviour if nested properties or additionalProperties are specified in the schema. This can either be true or undefined. False is forbidden. +boolean + +x-kubernetes-validations"x-kubernetes-validations describes a list of validation rules written in the CEL expression language. This field is an alpha-level. Using this field requires the feature gate `CustomResourceValidationExpressions` to be enabled. +arrayY +W +U#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule' +x-kubernetes-list-map-keys - rule + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keyrule +' +x-kubernetes-patch-strategymerge + + +Oio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrArray"JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps or an array of JSONSchemaProps. Mainly here for serialization purposes. + +Nio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrBoolq"oJSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. Defaults to true for the boolean property. + +Uio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaPropsOrStringArrayN"LJSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array. + +Iio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference";ServiceReference holds a reference to Service.legacy.k8s.io namespacename +object +> +name6")name is the name of the service. Required +string +M + namespace@"3namespace is the namespace of the service. Required +string +Y +pathQ"Dpath is an optional URL path at which the webhook will be contacted. +string + +portint32"port is an optional service port at which the webhook will be contacted. `port` should be a valid port number (1-65535, inclusive). Defaults to 443 for backward compatibility. +integer + +Gio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ValidationRule "RValidationRule describes a validation rule written in the CEL expression language.rule +object + +message"Message represents the message displayed when validation fails. The message is required if the Rule contains line breaks. The message must not contain line breaks. If unset, the message is "failed rule: {Rule}". e.g. "must be a URL with the host matching spec.host" +string + +rule"Rule represents the expression which will be evaluated by CEL. ref: https://github.com/google/cel-spec The Rule is scoped to the location of the x-kubernetes-validations extension in the schema. The `self` variable in the CEL expression is bound to the scoped value. Example: - Rule scoped to the root of a resource with a status subresource: {"rule": "self.status.actual <= self.spec.maxDesired"} + +If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable via `self.field` and field presence can be checked via `has(self.field)`. Null valued fields are treated as absent fields in CEL expressions. If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map are accessible via CEL macros and functions such as `self.all(...)`. If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and functions. If the Rule is scoped to a scalar, `self` is bound to the scalar value. Examples: - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"} - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"} - Rule scoped to a string value: {"rule": "self.startsWith('kube')"} + +The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible. + +Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL expressions. This includes: - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields. - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as: + - A schema with no type and x-kubernetes-preserve-unknown-fields set to true + - An array where the items schema is of an "unknown type" + - An object where the additionalProperties schema is of an "unknown type" + +Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible. Accessible property names are escaped according to the following rules when accessed in the expression: - '__' escapes to '__underscores__' - '.' escapes to '__dot__' - '-' escapes to '__dash__' - '/' escapes to '__slash__' - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are: + "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if", + "import", "let", "loop", "package", "namespace", "return". +Examples: + - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"} + - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"} + - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"} + +Equality on arrays with x-kubernetes-list-type of 'set' or 'map' ignores element order, i.e. [1, 2] == [2, 1]. Concatenation on arrays with x-kubernetes-list-type use the semantics of the list type: + - 'set': `X + Y` performs a union where the array positions of all elements in `X` are preserved and + non-intersecting elements in `Y` are appended, retaining their partial order. + - 'map': `X + Y` performs a merge where the array positions of all keys in `X` are preserved but the values + are overwritten by values in `Y` when the key sets of `X` and `Y` intersect. Elements in `Y` with + non-intersecting keys are appended, retaining their partial order. +string + +Lio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookClientConfig "WWebhookClientConfig contains the information to make a TLS connection with the webhook. +object + +caBundlebyte"caBundle is a PEM encoded CA bundle which will be used to validate the webhook's server certificate. If unspecified, system trust roots on the apiserver are used. +string + +service +W#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.ServiceReference"service is a reference to the service for this webhook. Either service or url must be specified. + +If the webhook is running within the cluster, then you should use `service`. + +url"url gives the location of the webhook, in standard URL form (`scheme://host:port/path`). Exactly one of `url` or `service` must be specified. + +The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. + +Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. + +The scheme must be "https"; the URL must begin with "https://". + +A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. + +Attempting to use a user or basic auth e.g. "user:password@" is not allowed. Fragments ("#...") and query parameters ("?...") are not allowed, either. +string + +Jio.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion" ::= + (Note that may be empty, from the "" case in .) + ::= 0 | 1 | ... | 9 ::= | ::= | . | . | . ::= "+" | "-" ::= | ::= | | ::= Ki | Mi | Gi | Ti | Pi | Ei + (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html) + ::= m | "" | k | M | G | T | P | E + (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.) + ::= "e" | "E" + +No matter which of the three exponent forms is used, no quantity may represent a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal places. Numbers larger or more precise will be capped or rounded up. (E.g.: 0.1m will rounded up to 1m.) This may be extended in the future if we require larger or smaller quantities. + +When a Quantity is parsed from a string, it will remember the type of suffix it had, and will use the same type again when it is serialized. + +Before serializing, Quantity will be put in "canonical form". This means that Exponent/suffix will be adjusted up or down (with a corresponding increase or decrease in Mantissa) such that: + a. No precision is lost + b. No fractional digits will be emitted + c. The exponent (or suffix) is as large as possible. +The sign will be omitted unless the number is negative. + +Examples: + 1.5 will be serialized as "1500m" + 1.5Gi will be serialized as "1536Mi" + +Note that the quantity will NEVER be internally represented by a floating point number. That is the whole point of this exercise. + +Non-canonical values will still parse as long as they are well formed, but will be re-emitted in their canonical form. (So always use canonical form, or don't diff.) + +This format is intended to make it difficult to use these numbers without writing some sort of special handling code in the hopes that that will cause implementors to also use a fixed point implementation. +string + +-io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup"YAPIGroup contains the name, the supported versions, and the preferred version of a group.nameversions +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +3 +name+"name is the name of the group. +string + +preferredVersion +K#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery"cpreferredVersion is the version preferred by the API server, which probably is the storage version. + +serverAddressByClientCIDRs"a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. +arrayP +N +L#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR + +versions"2versions are the versions supported in this group. +arrayO +M +K#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscoveryP +x-kubernetes-group-version-kind-+- group: "" + kind: APIGroup + version: v1 + + +1io.k8s.apimachinery.pkg.apis.meta.v1.APIGroupList"RAPIGroupList is a list of APIGroup, to allow clients to discover the API at /apis.groups +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +u +groupsk"groups is a list of APIGroup. +array? += +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIGroup + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +stringT +x-kubernetes-group-version-kind1/- group: "" + kind: APIGroupList + version: v1 + + +0io.k8s.apimachinery.pkg.apis.meta.v1.APIResource"JAPIResource specifies the name of a resource and whether it is namespaced.name singularName +namespacedkindverbs +object +} + +categorieso"Scategories is a list of the grouped resources this resource belongs to (e.g. 'all') +array +  +string + +group"group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale". +string +d +kind\"Okind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo') +string += +name5"(name is the plural name of the resource. +string +T + +namespacedF"8namespaced indicates if a resource is namespaced or not. +boolean +h + +shortNamesZ">shortNames is a list of suggested short names of the resource. +array +  +string + + singularName"singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface. +string + +storageVersionHash"The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates. +string + +verbs"verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy) +array +  +string + +version"version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)". +string + +4io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced. groupVersion resources +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +_ + groupVersionO"BgroupVersion is the group and version this APIResourceList is for. +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + + resources"Hresources contains the name of the resources and if they are namespaced. +arrayB +@ +>#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceW +x-kubernetes-group-version-kind42- group: "" + kind: APIResourceList + version: v1 + + +0io.k8s.apimachinery.pkg.apis.meta.v1.APIVersions "APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API.versionsserverAddressByClientCIDRs +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +serverAddressByClientCIDRs"a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. +arrayP +N +L#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR +Y +versionsM"1versions are the api versions that are available. +array +  +stringS +x-kubernetes-group-version-kind0.- group: "" + kind: APIVersions + version: v1 + + +.io.k8s.apimachinery.pkg.apis.meta.v1.Condition "TCondition contains details for one aspect of the current state of this API Resource.typestatuslastTransitionTimereasonmessage +object + + +lastTransitionTime +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + +messagev"imessage is a human readable message indicating details about the transition. This may be an empty string. +string + +observedGenerationint64"observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance. +integer + +reason"reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty. +string +L +statusB"5status of the condition, one of True, False, Unknown. +string +T +typeL"?type of condition in CamelCase or in foo.example.com/CamelCase. +string +- +2io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions-":DeleteOptions may be provided when deleting an API object. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +dryRun"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed +array +  +string + +gracePeriodSecondsint64"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. +integer + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +orphanDependents"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. +boolean + + preconditions +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"lMust be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + +propagationPolicy"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. +string +x-kubernetes-group-version-kind- group: "" + kind: DeleteOptions + version: v1 +- group: admission.k8s.io + kind: DeleteOptions + version: v1 +- group: admission.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: admissionregistration.k8s.io + kind: DeleteOptions + version: v1 +- group: admissionregistration.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: apiextensions.k8s.io + kind: DeleteOptions + version: v1 +- group: apiextensions.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: apiregistration.k8s.io + kind: DeleteOptions + version: v1 +- group: apiregistration.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: apps + kind: DeleteOptions + version: v1 +- group: apps + kind: DeleteOptions + version: v1beta1 +- group: apps + kind: DeleteOptions + version: v1beta2 +- group: authentication.k8s.io + kind: DeleteOptions + version: v1 +- group: authentication.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: authorization.k8s.io + kind: DeleteOptions + version: v1 +- group: authorization.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: autoscaling + kind: DeleteOptions + version: v1 +- group: autoscaling + kind: DeleteOptions + version: v2 +- group: autoscaling + kind: DeleteOptions + version: v2beta1 +- group: autoscaling + kind: DeleteOptions + version: v2beta2 +- group: batch + kind: DeleteOptions + version: v1 +- group: batch + kind: DeleteOptions + version: v1beta1 +- group: certificates.k8s.io + kind: DeleteOptions + version: v1 +- group: certificates.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: coordination.k8s.io + kind: DeleteOptions + version: v1 +- group: coordination.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: discovery.k8s.io + kind: DeleteOptions + version: v1 +- group: discovery.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: events.k8s.io + kind: DeleteOptions + version: v1 +- group: events.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: extensions + kind: DeleteOptions + version: v1beta1 +- group: flowcontrol.apiserver.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: flowcontrol.apiserver.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: flowcontrol.apiserver.k8s.io + kind: DeleteOptions + version: v1beta2 +- group: imagepolicy.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: internal.apiserver.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: networking.k8s.io + kind: DeleteOptions + version: v1 +- group: networking.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: node.k8s.io + kind: DeleteOptions + version: v1 +- group: node.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: node.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: policy + kind: DeleteOptions + version: v1 +- group: policy + kind: DeleteOptions + version: v1beta1 +- group: rbac.authorization.k8s.io + kind: DeleteOptions + version: v1 +- group: rbac.authorization.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: rbac.authorization.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: scheduling.k8s.io + kind: DeleteOptions + version: v1 +- group: scheduling.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: scheduling.k8s.io + kind: DeleteOptions + version: v1beta1 +- group: storage.k8s.io + kind: DeleteOptions + version: v1 +- group: storage.k8s.io + kind: DeleteOptions + version: v1alpha1 +- group: storage.k8s.io + kind: DeleteOptions + version: v1beta1 + + +5io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions_v2":DeleteOptions may be provided when deleting an API object. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +dryRun"When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed +array +  +string + +gracePeriodSecondsint64"The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. +integer + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +orphanDependents"Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. +boolean + + preconditions +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"lMust be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + +propagationPolicy"Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. +string + +-io.k8s.apimachinery.pkg.apis.meta.v1.Duration"Duration is a wrapper around time.Duration which supports correct marshaling to YAML and JSON. In particular, it marshals into strings, which can be used as map keys in json. +string + +-io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"FieldsV1 stores a set of fields in a data structure like a Trie, in JSON format. + +Each key is either a '.' representing the field itself, and will always map to an empty set, or a string representing a sub-field or item. The string will follow one of these four formats: 'f:', where is the name of a field in a struct, or key in a map 'v:', where is the exact json formatted value of a list item 'i:', where is position of a item in a list 'k:', where is a map of a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set. + +The exact format is defined in sigs.k8s.io/structured-merge-diff +object + +=io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery"wGroupVersion contains the "group/version" and "version" string of a version. It is made a struct to keep extensibility. groupVersionversion +object +i + groupVersionY"LgroupVersion specifies the API group and version in the form "group/version" +string + +version"~version specifies the version in the form of "version". This is to save the clients the trouble of splitting the GroupVersion. +string + +2io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. +object + +matchExpressions"VmatchExpressions is a list of label selector requirements. The requirements are ANDed. +arrayO +M +K#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement + + matchLabels"matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. +  +string +object" +x-kubernetes-map-type atomic + + +=io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"xA label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.keyoperator +object + +key"2key is the label key that the selector applies to. +string& +x-kubernetes-patch-merge-keykey +' +x-kubernetes-patch-strategymerge + + +operator"toperator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. +string + +values"values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. +array +  +string + +-io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. +object + +continue"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. +string + +remainingItemCountint64"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact. +integer + +resourceVersion"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string +t +selfLinkh"[Deprecated: selfLink is a legacy read-only field that is no longer populated by the system. +string + +0io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta_v2"ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. +object + +continue"continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. +string + +remainingItemCountint64"remainingItemCount is the number of subsequent items in the list which are not included in this list response. If the list request contained label or field selectors, then the number of remaining items is unknown and the field will be left unset and omitted during serialization. If the list is complete (either because it is not chunking or because this is the last chunk), then there are no more remaining items and this field will be left unset and omitted during serialization. Servers older than v1.15 do not set this field. The intended use of the remainingItemCount is *estimating* the size of a collection. Clients should not rely on the remainingItemCount to be set or to be exact. +integer + +resourceVersion"String that identifies the server's internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string + +selfLink"selfLink is a URL representing this object. Populated by the system. Read-only. + +DEPRECATED Kubernetes will stop propagating this field in 1.20 release and the field is planned to be removed in 1.21 release. +string + +7io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"sManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to. +object + + +apiVersion"APIVersion defines the version of this resource that this field set applies to. The format is "group/version" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted. +string + + +fieldsType"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: "FieldsV1" +string + +fieldsV1 +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"QFieldsV1 holds the first JSON version format as described in the "FieldsV1" type. +W +managerL"?Manager is an identifier of the workflow managing these fields. +string + + operation"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'. +string + + subresource"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource. +string + +time +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"Time is the timestamp of when the ManagedFields entry was added. The timestamp will also be updated if a field is added, the manager changes any of the owned fields value or removes a field. The timestamp does not update when a field is removed from the entry because another manager took it over. + +:io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry_v2 "sManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the resource that the fieldset applies to. +object + + +apiVersion"APIVersion defines the version of this resource that this field set applies to. The format is "group/version" just like the top-level APIVersion field. It is necessary to track the version of a field set because it cannot be automatically converted. +string + + +fieldsType"FieldsType is the discriminator for the different fields format and version. There is currently only one possible value: "FieldsV1" +string + +fieldsV1 +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"QFieldsV1 holds the first JSON version format as described in the "FieldsV1" type. +W +managerL"?Manager is an identifier of the workflow managing these fields. +string + + operation"Operation is the type of operation which lead to this ManagedFieldsEntry being created. The only valid values for this field are 'Apply' and 'Update'. +string + + subresource"Subresource is the name of the subresource used to update that object, or empty string if the object was updated through the main resource. The value of this field is used to distinguish between managers, even if they share the same name. For example, a status update will be distinct from a regular update using the same manager name. Note that the APIVersion field is not related to the Subresource field and it always corresponds to the version of the main resource. +string + +time +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"bTime is timestamp of when these fields were set. It should always be empty if Operation is 'Apply' + +.io.k8s.apimachinery.pkg.apis.meta.v1.MicroTimeV date-time">MicroTime is version of Time with microsecond level precision. +string +> +/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta="lObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. +object< + + annotations"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations +  +string +object + + clusterName"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25. + +The name in the go struct is changed to help clients detect accidental use. +string + +creationTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. + +Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +deletionGracePeriodSecondsint64"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. +integer + +deletionTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time" +DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. + +Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + +finalizers"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list. +array +  +string' +x-kubernetes-patch-strategymerge + + + generateName"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. + +If this field is specified and the generated name exists, the server will return a 409. + +Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency +string + + +generationint64"nA sequence number representing a specific generation of the desired state. Populated by the system. Read-only. +integer + +labels"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels +  +string +object + + managedFields"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like "ci-cd". The set of fields is always in the version that the workflow used when modifying the object. +arrayI +G +E#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry + +name"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + + namespace"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. + +Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces +string + +ownerReferences"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. +arrayE +C +A#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference& +x-kubernetes-patch-merge-keyuid +' +x-kubernetes-patch-strategymerge + + +resourceVersion"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. + +Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string +t +selfLinkh"[Deprecated: selfLink is a legacy read-only field that is no longer populated by the system. +string + +uid"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. + +Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string +> +2io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2="lObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. +object< + + annotations"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations +  +string +object + + clusterName"Deprecated: ClusterName is a legacy field that was always cleared by the system and never used; it will be removed completely in 1.25. + +The name in the go struct is changed to help clients detect accidental use. +string + +creationTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. + +Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +deletionGracePeriodSecondsint64"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. +integer + +deletionTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time" +DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. + +Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + +finalizers"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list. +array +  +string' +x-kubernetes-patch-strategymerge + + + generateName"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. + +If this field is specified and the generated name exists, the server will return a 409. + +Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency +string + + +generationint64"nA sequence number representing a specific generation of the desired state. Populated by the system. Read-only. +integer + +labels"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels +  +string +object + + managedFields"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like "ci-cd". The set of fields is always in the version that the workflow used when modifying the object. +arrayI +G +E#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry + +name"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + + namespace"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. + +Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces +string + +ownerReferences"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. +arrayH +F +D#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference_v2& +x-kubernetes-patch-merge-keyuid +' +x-kubernetes-patch-strategymerge + + +resourceVersion"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. + +Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string +t +selfLinkh"[Deprecated: selfLink is a legacy read-only field that is no longer populated by the system. +string + +uid"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. + +Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string +A +2io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v3@"lObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. +object? + + annotations"Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations +  +string +object + + clusterName"The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. +string + +creationTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. + +Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +deletionGracePeriodSecondsint64"Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. +integer + +deletionTimestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time" +DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. + +Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + +finalizers"Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. Finalizers may be processed and removed in any order. Order is NOT enforced because it introduces significant risk of stuck finalizers. finalizers is a shared field, any actor with permission can reorder it. If the finalizer list is processed in order, then this can lead to a situation in which the component responsible for the first finalizer in the list is waiting for a signal (field value, external system, or other) produced by a component responsible for a finalizer later in the list, resulting in a deadlock. Without enforced ordering finalizers are free to order amongst themselves and are not vulnerable to ordering changes in the list. +array +  +string' +x-kubernetes-patch-strategymerge + + + generateName"GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. + +If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). + +Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency +string + + +generationint64"nA sequence number representing a specific generation of the desired state. Populated by the system. Read-only. +integer + +labels"Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels +  +string +object + + managedFields"ManagedFields maps workflow-id and version to the set of fields that are managed by that workflow. This is mostly for internal housekeeping, and users typically shouldn't need to set or understand this field. A workflow can be the user's name, a controller's name, or the name of a specific apply path like "ci-cd". The set of fields is always in the version that the workflow used when modifying the object. +arrayL +J +H#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry_v2 + +name"Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + + namespace"Namespace defines the space within which each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. + +Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces +string + +ownerReferences"List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. +arrayH +F +D#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference_v3& +x-kubernetes-patch-merge-keyuid +' +x-kubernetes-patch-strategymerge + + +resourceVersion"An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. + +Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency +string + +selfLink"SelfLink is a URL representing this object. Populated by the system. Read-only. + +DEPRECATED Kubernetes will stop propagating this field in 1.20 release and the field is planned to be removed in 1.21 release. +string + +uid"UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. + +Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string + + +3io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference +"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. +apiVersionkindnameuid +object +7 + +apiVersion)"API version of the referent. +string + +blockOwnerDeletion"If true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs "delete" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. +boolean +V + +controllerH":If true, this reference points to the managing controller. +boolean + +kind"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +l +named"WName of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string +i +uidb"UUID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string" +x-kubernetes-map-type atomic + + + +6io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference_v2 +"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. +apiVersionkindnameuid +object +7 + +apiVersion)"API version of the referent. +string + +blockOwnerDeletion"If true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. See https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion for how the garbage collector interacts with this field and enforces the foreground deletion. Defaults to false. To set this field, a user needs "delete" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. +boolean +V + +controllerH":If true, this reference points to the managing controller. +boolean + +kind"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +l +named"WName of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string +i +uidb"UUID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string" +x-kubernetes-map-type atomic + + +6io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference_v3"OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. +apiVersionkindnameuid +object +7 + +apiVersion)"API version of the referent. +string + +blockOwnerDeletion"If true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs "delete" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. +boolean +V + +controllerH":If true, this reference points to the managing controller. +boolean + +kind"Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +l +named"WName of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names +string +i +uidb"UUID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string" +x-kubernetes-map-type atomic + + +*io.k8s.apimachinery.pkg.apis.meta.v1.Patche"XPatch is provided to give a concrete name and type to the Kubernetes PATCH request body. +object + +2io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions"ZPreconditions must be fulfilled before an operation (update, delete, etc.) is carried out. +objectu +D +resourceVersion1"$Specifies the target ResourceVersion +string +- +uid&"Specifies the target UID. +string + +>io.k8s.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR"ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. +clientCIDR serverAddress +object + + +clientCIDRr"eThe CIDR with which clients can match their IP to figure out the server address that they should use. +string + + serverAddress"Address of this server, suitable for a client that matches the above CIDR. This can be a hostname, hostname:port, IP or IP:port. +string + ++io.k8s.apimachinery.pkg.apis.meta.v1.Status"CStatus is a return value for calls that don't return other objects. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +V +codeNint32"9Suggested HTTP return code for this status, 0 if not set. +integer + +details +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails"Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +U +messageJ"=A human-readable description of the status of this operation. +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + +reason"A machine-readable description of why this operation is in the "Failure" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. +string + +status"Status of the operation. One of: "Success" or "Failure". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status +stringN +x-kubernetes-group-version-kind+)- group: "" + kind: Status + version: v1 + + +0io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause"xStatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. +object + +field"The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. + +Examples: + "name" - the field "name" on the current resource + "items[0].name" - the field "name" on the first array entry in "items" +string + +messaget"gA human-readable description of the cause of the error. This field may be presented as-is to a reader. +string + +reason"sA machine-readable description of the cause of the error. If this value is empty there is no information available. +string + +2io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. +object + +causes"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. +arrayB +@ +>#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause +b +groupY"LThe group attribute of the resource associated with the status StatusReason. +string + +kind"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +name"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). +string + +retryAfterSecondsint32"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. +integer + +uid"UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string + +5io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails_v2 "StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. +object + +causes"The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. +arrayB +@ +>#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.StatusCause +b +groupY"LThe group attribute of the resource associated with the status StatusReason. +string + +kind"The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +name"The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). +string + +retryAfterSecondsint32"If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. +integer + +uid"UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids +string + +.io.k8s.apimachinery.pkg.apis.meta.v1.Status_v2"CStatus is a return value for calls that don't return other objects. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +V +codeNint32"9Suggested HTTP return code for this status, 0 if not set. +integer + +details +C#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.StatusDetails_v2"Extended data associated with the reason. Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type. + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string +U +messageJ"=A human-readable description of the status of this operation. +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds + +reason"A machine-readable description of why this operation is in the "Failure" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. +string + +status"Status of the operation. One of: "Success" or "Failure". More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status +string + +)io.k8s.apimachinery.pkg.apis.meta.v1.Time date-time"Time is a wrapper around time.Time which supports correct marshaling to YAML and JSON. Wrappers are provided for many of the factory methods that the time package offers. +string + +/io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent"6Event represents a single event to a watched resource.typeobject +object + +object +:#/definitions/io.k8s.apimachinery.pkg.runtime.RawExtension"Object is: + * If Type is Added or Modified: the new state of the object. + * If Type is Deleted: the state of the object immediately before deletion. + * If Type is Error: *Status is recommended; other types may make sense + depending on context. + +type  +string +x-kubernetes-group-version-kind- group: "" + kind: WatchEvent + version: v1 +- group: admission.k8s.io + kind: WatchEvent + version: v1 +- group: admission.k8s.io + kind: WatchEvent + version: v1beta1 +- group: admissionregistration.k8s.io + kind: WatchEvent + version: v1 +- group: admissionregistration.k8s.io + kind: WatchEvent + version: v1beta1 +- group: apiextensions.k8s.io + kind: WatchEvent + version: v1 +- group: apiextensions.k8s.io + kind: WatchEvent + version: v1beta1 +- group: apiregistration.k8s.io + kind: WatchEvent + version: v1 +- group: apiregistration.k8s.io + kind: WatchEvent + version: v1beta1 +- group: apps + kind: WatchEvent + version: v1 +- group: apps + kind: WatchEvent + version: v1beta1 +- group: apps + kind: WatchEvent + version: v1beta2 +- group: authentication.k8s.io + kind: WatchEvent + version: v1 +- group: authentication.k8s.io + kind: WatchEvent + version: v1beta1 +- group: authorization.k8s.io + kind: WatchEvent + version: v1 +- group: authorization.k8s.io + kind: WatchEvent + version: v1beta1 +- group: autoscaling + kind: WatchEvent + version: v1 +- group: autoscaling + kind: WatchEvent + version: v2 +- group: autoscaling + kind: WatchEvent + version: v2beta1 +- group: autoscaling + kind: WatchEvent + version: v2beta2 +- group: batch + kind: WatchEvent + version: v1 +- group: batch + kind: WatchEvent + version: v1beta1 +- group: certificates.k8s.io + kind: WatchEvent + version: v1 +- group: certificates.k8s.io + kind: WatchEvent + version: v1beta1 +- group: coordination.k8s.io + kind: WatchEvent + version: v1 +- group: coordination.k8s.io + kind: WatchEvent + version: v1beta1 +- group: discovery.k8s.io + kind: WatchEvent + version: v1 +- group: discovery.k8s.io + kind: WatchEvent + version: v1beta1 +- group: events.k8s.io + kind: WatchEvent + version: v1 +- group: events.k8s.io + kind: WatchEvent + version: v1beta1 +- group: extensions + kind: WatchEvent + version: v1beta1 +- group: flowcontrol.apiserver.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: flowcontrol.apiserver.k8s.io + kind: WatchEvent + version: v1beta1 +- group: flowcontrol.apiserver.k8s.io + kind: WatchEvent + version: v1beta2 +- group: imagepolicy.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: internal.apiserver.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: networking.k8s.io + kind: WatchEvent + version: v1 +- group: networking.k8s.io + kind: WatchEvent + version: v1beta1 +- group: node.k8s.io + kind: WatchEvent + version: v1 +- group: node.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: node.k8s.io + kind: WatchEvent + version: v1beta1 +- group: policy + kind: WatchEvent + version: v1 +- group: policy + kind: WatchEvent + version: v1beta1 +- group: rbac.authorization.k8s.io + kind: WatchEvent + version: v1 +- group: rbac.authorization.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: rbac.authorization.k8s.io + kind: WatchEvent + version: v1beta1 +- group: scheduling.k8s.io + kind: WatchEvent + version: v1 +- group: scheduling.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: scheduling.k8s.io + kind: WatchEvent + version: v1beta1 +- group: storage.k8s.io + kind: WatchEvent + version: v1 +- group: storage.k8s.io + kind: WatchEvent + version: v1alpha1 +- group: storage.k8s.io + kind: WatchEvent + version: v1beta1 + + + +,io.k8s.apimachinery.pkg.runtime.RawExtension +" +RawExtension is used to hold extensions in external versions. + +To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. + +// Internal package: type MyAPIObject struct { + runtime.TypeMeta `json:",inline"` + MyPlugin runtime.Object `json:"myPlugin"` +} type PluginA struct { + AOption string `json:"aOption"` +} + +// External package: type MyAPIObject struct { + runtime.TypeMeta `json:",inline"` + MyPlugin runtime.RawExtension `json:"myPlugin"` +} type PluginA struct { + AOption string `json:"aOption"` +} + +// On the wire, the JSON will look something like this: { + "kind":"MyAPIObject", + "apiVersion":"v1", + "myPlugin": { + "kind":"PluginA", + "aOption":"foo", + }, +} + +So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package's DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) +object + +/io.k8s.apimachinery.pkg.util.intstr.IntOrString int-or-string"IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number. +string + +$io.k8s.apimachinery.pkg.version.Info"TInfo contains versioning information. how we'll want to distribute that information.majorminor +gitVersion gitCommit gitTreeState buildDate goVersioncompilerplatform +object + + buildDate  +string + +compiler  +string + + gitCommit  +string + + gitTreeState  +string + + +gitVersion  +string + + goVersion  +string + +major  +string + +minor  +string + +platform  +string +C ++io.k8s.autoscaling.v1.VerticalPodAutoscalerC"VerticalPodAutoscaler is the configuration for a vertical pod autoscaler, which automatically manages pod resources based on historical and real time resource utilization.spec +objectA + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata +! +spec!"Specification of the behavior of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status. targetRef +object + + recommenders"Recommender responsible for generating recommendation for this object. List should be empty (then the default recommender will generate the recommendation) or contain exactly one recommender. +array +"VerticalPodAutoscalerRecommenderSelector points to a specific Vertical Pod Autoscaler recommender. In the future it might pass parameters to the recommender.name +objecti +g +name_"RName of the recommender responsible for generating recommendation for this object. +string + +resourcePolicy"Controls how the autoscaler computes recommended resources. The resource policy may be used to set constraints on the recommendations for individual containers. If not specified, the autoscaler computes recommended resources for all containers in the pod, without additional constraints. +object + +containerPolicies " Per-container resource policies. +array + "lContainerResourcePolicy controls how autoscaler computes the recommended resources for a specific container. +object + + + containerName"Name of the container or DefaultContainerResourcePolicy, in which case the policy is used by the containers that don't have their own policy specified. +string + +controlledResources"Specifies the type of recommendations that will be computed (and possibly applied) by VPA. If not specified, the default of [ResourceCPU, ResourceMemory] will be used. +arrayX +V"IResourceName is the name identifying various resources in a ResourceList. +string + +controlledValues"YSpecifies which resource values should be controlled. The default is "RequestsAndLimits".RequestsAndLimits + RequestsOnly + +string + + +maxAllowed"pSpecifies the maximum amount of resources that will be recommended for the container. The default is no maximum. +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object + + +minAllowed"pSpecifies the minimal amount of resources that will be recommended for the container. The default is no minimum. +jq^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$% +x-kubernetes-int-or-stringtrue + +object +o +modeg"GWhether autoscaler is enabled for the container. The default is "Auto".Auto +Off + +string + + targetRef"TargetRef points to the controller managing the set of pods for the autoscaler to control - e.g. Deployment, StatefulSet. VerticalPodAutoscaler can be targeted at controller implementing scale subresource (the pod set is retrieved from the controller's ScaleStatus) or some well known controllers (e.g. for DaemonSet the pod set is read from the controller's spec). If VerticalPodAutoscaler cannot use specified target it will report ConfigUnsupported condition. Note that VerticalPodAutoscaler does not require full implementation of scale subresource - it will not use it to modify the replica count. The only thing retrieved is a label selector matching pods grouped by the target resource.kindname +object +6 + +apiVersion("API version of the referent +string + +kind"Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds" +string +l +named"WName of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names +string + + updatePolicy"Describes the rules on how changes are applied to the pods. If not specified, all fields in the `PodUpdatePolicy` are set to their default values. +object + + minReplicasint32"Minimal number of replicas which need to be alive for Updater to attempt pod eviction (pending other checks like PDB). Only positive values are allowed. Overrides global '--min-replicas' flag. +integer + + +updateMode"UControls when autoscaler applies changes to the pod resources. The default is 'Auto'.Off + +Initial +  Recreate +Auto + +string + +status")Current information about the autoscaler. +object + + +conditions"Conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. +array +"aVerticalPodAutoscalerCondition describes the state of a VerticalPodAutoscaler at a certain point.statustype +object + +lastTransitionTimeq date-time"YlastTransitionTime is the last time the condition transitioned from one status to another +string +g +message\"Omessage is a human-readable explanation containing details about the transition +string +P +reasonF"9reason is the reason for the condition's last transition. +string +S +statusI" date-time"1Timestamp of the fist sample from the histograms. +Q +lastSampleStart> date-time"1Timestamp of the last sample from the histograms. +K +lastUpdateTime9 date-time",The time when the status was last refreshed. + +memoryHistogram"2Checkpoint of histogram for consumption of memory. +object +l + bucketWeights["'Map from bucket index to bucket weight./ +$x-kubernetes-preserve-unknown-fieldstrue + +c +referenceTimestampM date-time"@Reference timestamp for samples collected within this histogram. +d + totalWeightU"HSum of samples to be used as denominator for weights from BucketWeights. +number +M +totalSamplesCount8"*Total number of samples in the histograms. +integer +A +version6")Version of the format of the stored data. +stringw +x-kubernetes-group-version-kindTR- group: autoscaling.k8s.io + kind: VerticalPodAutoscalerCheckpoint + version: v1 + + + +9io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpointList +"PVerticalPodAutoscalerCheckpointList is a list of VerticalPodAutoscalerCheckpointitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"List of verticalpodautoscalercheckpoints. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +arrayG +E +C#/definitions/io.k8s.autoscaling.v1.VerticalPodAutoscalerCheckpoint + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds{ +x-kubernetes-group-version-kindXV- group: autoscaling.k8s.io + kind: VerticalPodAutoscalerCheckpointList + version: v1 + + + +/io.k8s.autoscaling.v1.VerticalPodAutoscalerList " date-time"1Timestamp of the fist sample from the histograms. +Q +lastSampleStart> date-time"1Timestamp of the last sample from the histograms. +K +lastUpdateTime9 date-time",The time when the status was last refreshed. + +memoryHistogram"2Checkpoint of histogram for consumption of memory. +object +l + bucketWeights["'Map from bucket index to bucket weight./ +$x-kubernetes-preserve-unknown-fieldstrue + +c +referenceTimestampM date-time"@Reference timestamp for samples collected within this histogram. +d + totalWeightU"HSum of samples to be used as denominator for weights from BucketWeights. +number +M +totalSamplesCount8"*Total number of samples in the histograms. +integer +A +version6")Version of the format of the stored data. +string| +x-kubernetes-group-version-kindYW- group: autoscaling.k8s.io + kind: VerticalPodAutoscalerCheckpoint + version: v1beta2 + + + +>io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpointList +"PVerticalPodAutoscalerCheckpointList is a list of VerticalPodAutoscalerCheckpointitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"List of verticalpodautoscalercheckpoints. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +arrayL +J +H#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerCheckpoint + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +x-kubernetes-group-version-kind][- group: autoscaling.k8s.io + kind: VerticalPodAutoscalerCheckpointList + version: v1beta2 + + + +4io.k8s.autoscaling.v1beta2.VerticalPodAutoscalerList "#/definitions/io.k8s.autoscaling.v1beta2.VerticalPodAutoscaler + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsv +x-kubernetes-group-version-kindSQ- group: autoscaling.k8s.io + kind: VerticalPodAutoscalerList + version: v1beta2 + + +=io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService +"[APIService represents a server for a particular GroupVersion. Name must be "version.group". +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +=#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +spec +O#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec"FSpec contains information for locating and communicating with a server + +status +Q#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus"7Status contains derived information about an API serverf +x-kubernetes-group-version-kindCA- group: apiregistration.k8s.io + kind: APIService + version: v1 + + +Fio.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition"NAPIServiceCondition describes the state of an APIService at a particular pointtypestatus +object + +lastTransitionTime{ +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"@Last time the condition transitioned from one status to another. +X +messageM"@Human-readable message indicating details about last transition. +string +^ +reasonT"GUnique, one-word, CamelCase reason for the condition's last transition. +string +Z +statusP"CStatus is the status of the condition. Can be True, False, Unknown. +string +7 +type/""Type is the type of the condition. +string + +Aio.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceList "/APIServiceList is a list of APIService objects.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items}"Items is the list of APIService +arrayO +M +K#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIService + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"~Standard list metadata More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadataj +x-kubernetes-group-version-kindGE- group: apiregistration.k8s.io + kind: APIServiceList + version: v1 + + +Aio.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceSpec"APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.groupPriorityMinimumversionPriority +object + +caBundlebyte"CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate. If unspecified, system trust roots on the apiserver are used. +string# +x-kubernetes-list-type atomic + +C +group:"-Group is the API group name this server hosts +string + +groupPriorityMinimumint32"GroupPriorityMininum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMininum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We'd recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s +integer + +insecureSkipTLSVerify"InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead. +boolean + +service +Q#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference"Service is a reference to the service for this API server. It must communicate on port 443. If the Service is nil, that means the handling for the API groupversion is handled locally on this server. The call will simply delegate to the normal handler chain to be fulfilled. +X +versionM"@Version is the API version this server hosts. For example, "v1" +string + +versionPriorityint32"VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it's inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is "kube-like", it will sort above non "kube-like" version strings, which are ordered lexicographically. "Kube-like" versions start with a "v", then are followed by a number (the major version), then optionally the string "alpha" or "beta" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. +integer + +Cio.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceStatus"AAPIServiceStatus contains derived information about an API server +object + + +conditions"$Current service state of apiService. +arrayX +V +T#/definitions/io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.APIServiceCondition' +x-kubernetes-list-map-keys - type + +x-kubernetes-list-typemap +' +x-kubernetes-patch-merge-keytype +' +x-kubernetes-patch-strategymerge + + +Cio.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference";ServiceReference holds a reference to Service.legacy.k8s.io +object +4 +name,"Name is the name of the service +string +C + namespace6")Namespace is the namespace of the service +string + +portint32"If specified, the port on the service that hosting webhook. Default to 443 for backward compatibility. `port` should be a valid port number (1-65535, inclusive). +integer + +8io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics"#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta_v2"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsh +x-kubernetes-group-version-kindEC- group: metrics.k8s.io + kind: NodeMetricsList + version: v1beta1 + + +2io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics "0PodMetrics sets resource usage metrics of a pod. timestampwindow +containers +object + + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + + +containers"EMetrics for all containers are collected within the same time window. +arrayJ +H +F#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.ContainerMetrics + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v3"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + + timestamp +7#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Time"|The following fields define time interval from which metrics were collected from the interval [Timestamp-Window, Timestamp]. +G +window= +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.Durationc +x-kubernetes-group-version-kind@>- group: metrics.k8s.io + kind: PodMetrics + version: v1beta1 + + +6io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetricsList"'PodMetricsList is a list of PodMetrics.items +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string +p +itemsg"List of pod metrics. +arrayD +B +@#/definitions/io.k8s.metrics.pkg.apis.metrics.v1beta1.PodMetrics + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +>#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta_v2"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kindsg +x-kubernetes-group-version-kindDB- group: metrics.k8s.io + kind: PodMetricsList + version: v1beta1 + + +=io.open-cluster-management.cluster.v1alpha1.PlacementDecision"PlacementDecision indicates a decision from a placement PlacementDecision should has a label cluster.open-cluster-management.io/placement={placement name} to reference a certain placement. + If a placement has spec.numberOfClusters specified, the total number of decisions contained in status.decisions of PlacementDecisions should always be NumberOfClusters; otherwise, the total number of decisions should be the number of ManagedClusters which match the placement requirements. + Some of the decisions might be empty when there are no enough ManagedClusters meet the placement requirements. +object + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +@#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta_v2"Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata + +status"=Status represents the current status of the PlacementDecision decisions +object + + decisions"pDecisions is a slice of decisions according to a placement The number of decisions should not be larger than 100 +array +"rClusterDecision represents a decision from a placement An empty ClusterDecision indicates it is not scheduled yet. clusterNamereason +object + + clusterName"ClusterName is the name of the ManagedCluster. If it is not empty, its value should be unique cross all placement decisions for the Placement. +string +W +reasonM"@Reason represents the reason why the ManagedCluster is selected. +string +x-kubernetes-group-version-kind\Z- group: cluster.open-cluster-management.io + kind: PlacementDecision + version: v1alpha1 + + + +Aio.open-cluster-management.cluster.v1alpha1.PlacementDecisionList "4PlacementDecisionList is a list of PlacementDecisionitems + + +apiVersion"APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources +string + +items"zList of placementdecisions. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md +arrayO +M +K#/definitions/io.open-cluster-management.cluster.v1alpha1.PlacementDecision + +kind"Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +string + +metadata +;#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds +x-kubernetes-group-version-kind`^- group: cluster.open-cluster-management.io + kind: PlacementDecisionList + version: v1alpha1 +b + + BearerTokenjO +M + BearerToken>< +apiKey authorizationheader"Bearer Token authentication \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/sealedsecret-config.json b/gitops-engine/pkg/diff/testdata/sealedsecret-config.json new file mode 100644 index 0000000000000..407e5b2693da5 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/sealedsecret-config.json @@ -0,0 +1,14 @@ +{ + "kind": "SealedSecret", + "apiVersion": "bitnami.com/v1alpha1", + "metadata": { + "name": "mysecret", + "namespace": "default", + "creationTimestamp": null + }, + "spec": { + "encryptedData": { + "foo": "AgCW7b6fmehUc6MmdTfbAEpOx9zcYuXZGKID6llLUqLnXiLHfeF8yPY6wpecv+/GETeu+neCHZbonSRGWsK723rqD2S9GYUT6WT1TJW1+dYEJQrCYg3AYw9Awn7Tli5854oGfvKH2cfu++Yjq7EW7SfEA3E+12uAYM+ennQeib4HNmjxJUf3dVAjvYBrpyl/zMflla5Mi1mkBSLgqzlUitEyCNx63lFCdRw03BZAMOYuMVVRFDP5iobQFBl/NV9f04eMV1B8aTVvGoU81eX2FDZ6b+/DQx4TVdGuZTgViPcThiih4ahB2/9Qyk5OZlubmQeM7qMn8uo53kZy/3sOhqikr5TNGz52BJCoRFhw3HYw4Qm0NTxC/lYnuxnkHq8eXj1KMYVR3YrxnLy3sMH07I3OGsczwabUFvGyOp8SOOOICJ1Np7DmQSW/6U3bHey3sILAJYrZkeU8hjPZ1OU+7Ydr9En5sr048xuvfNblQCfhNGfAePNI0gD/Y6+ubmHM6s/vK4c3kDDVV2nY9suE84T6Zoxd0zEZXftay6+GaFz4lb3qKdFTxTMegzU5RxGxFm0bF75Y7EIWjulhNnC2PzQ6EK6sH5R6HwfZ5pbE3MUMYF4Ww3v3oo3z15EJ7l86//bIiKCQcuM7tFNsJYlubRAEhpcZFunUSKW8eqodjxstYnCwqNxHFKr8aybtsUouC93ZZ3M=" + } + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/sealedsecret-live.json b/gitops-engine/pkg/diff/testdata/sealedsecret-live.json new file mode 100644 index 0000000000000..476c30120b6eb --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/sealedsecret-live.json @@ -0,0 +1,21 @@ +{ + "apiVersion": "bitnami.com/v1alpha1", + "kind": "SealedSecret", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"bitnami.com/v1alpha1\",\"kind\":\"SealedSecret\",\"metadata\":{\"annotations\":{},\"creationTimestamp\":null,\"name\":\"mysecret\",\"namespace\":\"default\"},\"spec\":{\"encryptedData\":{\"foo\":\"AgCW7b6fmehUc6MmdTfbAEpOx9zcYuXZGKID6llLUqLnXiLHfeF8yPY6wpecv+/GETeu+neCHZbonSRGWsK723rqD2S9GYUT6WT1TJW1+dYEJQrCYg3AYw9Awn7Tli5854oGfvKH2cfu++Yjq7EW7SfEA3E+12uAYM+ennQeib4HNmjxJUf3dVAjvYBrpyl/zMflla5Mi1mkBSLgqzlUitEyCNx63lFCdRw03BZAMOYuMVVRFDP5iobQFBl/NV9f04eMV1B8aTVvGoU81eX2FDZ6b+/DQx4TVdGuZTgViPcThiih4ahB2/9Qyk5OZlubmQeM7qMn8uo53kZy/3sOhqikr5TNGz52BJCoRFhw3HYw4Qm0NTxC/lYnuxnkHq8eXj1KMYVR3YrxnLy3sMH07I3OGsczwabUFvGyOp8SOOOICJ1Np7DmQSW/6U3bHey3sILAJYrZkeU8hjPZ1OU+7Ydr9En5sr048xuvfNblQCfhNGfAePNI0gD/Y6+ubmHM6s/vK4c3kDDVV2nY9suE84T6Zoxd0zEZXftay6+GaFz4lb3qKdFTxTMegzU5RxGxFm0bF75Y7EIWjulhNnC2PzQ6EK6sH5R6HwfZ5pbE3MUMYF4Ww3v3oo3z15EJ7l86//bIiKCQcuM7tFNsJYlubRAEhpcZFunUSKW8eqodjxstYnCwqNxHFKr8aybtsUouC93ZZ3M=\"}}}\n" + }, + "creationTimestamp": "2019-01-15T16:37:05Z", + "generation": 1, + "name": "mysecret", + "namespace": "default", + "resourceVersion": "102734", + "selfLink": "/apis/bitnami.com/v1alpha1/namespaces/default/sealedsecrets/mysecret", + "uid": "cb3c8363-18e3-11e9-afc1-a6a55e696d25" + }, + "spec": { + "encryptedData": { + "foo": "AgCW7b6fmehUc6MmdTfbAEpOx9zcYuXZGKID6llLUqLnXiLHfeF8yPY6wpecv+/GETeu+neCHZbonSRGWsK723rqD2S9GYUT6WT1TJW1+dYEJQrCYg3AYw9Awn7Tli5854oGfvKH2cfu++Yjq7EW7SfEA3E+12uAYM+ennQeib4HNmjxJUf3dVAjvYBrpyl/zMflla5Mi1mkBSLgqzlUitEyCNx63lFCdRw03BZAMOYuMVVRFDP5iobQFBl/NV9f04eMV1B8aTVvGoU81eX2FDZ6b+/DQx4TVdGuZTgViPcThiih4ahB2/9Qyk5OZlubmQeM7qMn8uo53kZy/3sOhqikr5TNGz52BJCoRFhw3HYw4Qm0NTxC/lYnuxnkHq8eXj1KMYVR3YrxnLy3sMH07I3OGsczwabUFvGyOp8SOOOICJ1Np7DmQSW/6U3bHey3sILAJYrZkeU8hjPZ1OU+7Ydr9En5sr048xuvfNblQCfhNGfAePNI0gD/Y6+ubmHM6s/vK4c3kDDVV2nY9suE84T6Zoxd0zEZXftay6+GaFz4lb3qKdFTxTMegzU5RxGxFm0bF75Y7EIWjulhNnC2PzQ6EK6sH5R6HwfZ5pbE3MUMYF4Ww3v3oo3z15EJ7l86//bIiKCQcuM7tFNsJYlubRAEhpcZFunUSKW8eqodjxstYnCwqNxHFKr8aybtsUouC93ZZ3M=" + } + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/smd-deploy-config.yaml b/gitops-engine/pkg/diff/testdata/smd-deploy-config.yaml new file mode 100644 index 0000000000000..10bfcb6c24554 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-deploy-config.yaml @@ -0,0 +1,33 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + labels: + app: missing + applications.argoproj.io/app-name: nginx + something-else: bla + name: nginx-deployment + namespace: default +spec: + replicas: 2 + selector: + matchLabels: + app: nginx + template: + metadata: + labels: + app: nginx + applications.argoproj.io/app-name: nginx + spec: + containers: + - image: 'nginx:1.23.1' + imagePullPolicy: Never + livenessProbe: + exec: + command: + - cat + - non-existent-file + initialDelaySeconds: 5 + periodSeconds: 180 + name: nginx + ports: + - containerPort: 80 diff --git a/gitops-engine/pkg/diff/testdata/smd-deploy-live.yaml b/gitops-engine/pkg/diff/testdata/smd-deploy-live.yaml new file mode 100644 index 0000000000000..26fef4c2665cb --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-deploy-live.yaml @@ -0,0 +1,149 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: '1' + creationTimestamp: '2022-09-18T23:50:25Z' + generation: 1 + labels: + app: missing + applications.argoproj.io/app-name: nginx + something-else: bla + managedFields: + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:labels': + 'f:app': {} + 'f:applications.argoproj.io/app-name': {} + 'f:something-else': {} + 'f:spec': + 'f:replicas': {} + 'f:selector': {} + 'f:template': + 'f:metadata': + 'f:labels': + 'f:app': {} + 'f:applications.argoproj.io/app-name': {} + 'f:spec': + 'f:containers': + 'k:{"name":"nginx"}': + .: {} + 'f:image': {} + 'f:imagePullPolicy': {} + 'f:livenessProbe': + 'f:exec': + 'f:command': {} + 'f:initialDelaySeconds': {} + 'f:periodSeconds': {} + 'f:name': {} + 'f:ports': + 'k:{"containerPort":80,"protocol":"TCP"}': + .: {} + 'f:containerPort': {} + manager: argocd-controller + operation: Apply + time: '2022-09-18T23:50:25Z' + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + .: {} + 'f:deployment.kubernetes.io/revision': {} + 'f:status': + 'f:availableReplicas': {} + 'f:conditions': + .: {} + 'k:{"type":"Available"}': + .: {} + 'f:lastTransitionTime': {} + 'f:lastUpdateTime': {} + 'f:message': {} + 'f:reason': {} + 'f:status': {} + 'f:type': {} + 'k:{"type":"Progressing"}': + .: {} + 'f:lastTransitionTime': {} + 'f:lastUpdateTime': {} + 'f:message': {} + 'f:reason': {} + 'f:status': {} + 'f:type': {} + 'f:observedGeneration': {} + 'f:readyReplicas': {} + 'f:replicas': {} + 'f:updatedReplicas': {} + manager: kube-controller-manager + operation: Update + subresource: status + time: '2022-09-23T18:30:59Z' + name: nginx-deployment + namespace: default + resourceVersion: '7492752' + uid: 731f7434-d3d9-47fa-b179-d9368a84f7c9 +spec: + progressDeadlineSeconds: 600 + replicas: 2 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: nginx + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: nginx + applications.argoproj.io/app-name: nginx + spec: + containers: + - image: 'nginx:1.23.1' + imagePullPolicy: Never + livenessProbe: + exec: + command: + - cat + - non-existent-file + failureThreshold: 3 + initialDelaySeconds: 5 + periodSeconds: 180 + successThreshold: 1 + timeoutSeconds: 1 + name: nginx + ports: + - containerPort: 80 + protocol: TCP + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 2 + conditions: + - lastTransitionTime: '2022-09-18T23:50:25Z' + lastUpdateTime: '2022-09-18T23:50:26Z' + message: ReplicaSet "nginx-deployment-6d68ff5f86" has successfully progressed. + reason: NewReplicaSetAvailable + status: 'True' + type: Progressing + - lastTransitionTime: '2022-09-23T18:30:59Z' + lastUpdateTime: '2022-09-23T18:30:59Z' + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: 'True' + type: Available + observedGeneration: 1 + readyReplicas: 2 + replicas: 2 + updatedReplicas: 2 diff --git a/gitops-engine/pkg/diff/testdata/smd-deploy2-config.yaml b/gitops-engine/pkg/diff/testdata/smd-deploy2-config.yaml new file mode 100644 index 0000000000000..1c141e3e13c4a --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-deploy2-config.yaml @@ -0,0 +1,36 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + labels: + app: missing + applications.argoproj.io/app-name: nginx + something-else: bla + name: nginx-deployment + namespace: default +spec: + replicas: 2 + selector: + matchLabels: + app: nginx + template: + metadata: + labels: + app: nginx + applications.argoproj.io/app-name: nginx + spec: + containers: + - image: 'nginx:1.23.1' + imagePullPolicy: Never + livenessProbe: + exec: + command: + - cat + - non-existent-file + initialDelaySeconds: 5 + periodSeconds: 180 + name: nginx + ports: + - containerPort: 8081 + protocol: UDP + - containerPort: 80 + protocol: TCP diff --git a/gitops-engine/pkg/diff/testdata/smd-deploy2-live.yaml b/gitops-engine/pkg/diff/testdata/smd-deploy2-live.yaml new file mode 100644 index 0000000000000..94535a85dc534 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-deploy2-live.yaml @@ -0,0 +1,161 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: '1' + creationTimestamp: '2022-09-18T23:50:25Z' + generation: 1 + labels: + app: missing + applications.argoproj.io/app-name: nginx + something-else: bla + managedFields: + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:labels': + 'f:app': {} + 'f:applications.argoproj.io/app-name': {} + 'f:something-else': {} + 'f:spec': + 'f:replicas': {} + 'f:selector': {} + 'f:template': + 'f:metadata': + 'f:labels': + 'f:app': {} + 'f:applications.argoproj.io/app-name': {} + 'f:spec': + 'f:containers': + 'k:{"name":"nginx"}': + .: {} + 'f:image': {} + 'f:imagePullPolicy': {} + 'f:livenessProbe': + 'f:exec': + 'f:command': {} + 'f:initialDelaySeconds': {} + 'f:periodSeconds': {} + 'f:name': {} + 'f:ports': + 'k:{"containerPort":80,"protocol":"TCP"}': + .: {} + 'f:containerPort': {} + 'f:protocol': {} + 'f:resources': + 'f:requests': + 'f:cpu': {} + 'f:memory': {} + manager: argocd-controller + operation: Apply + time: '2022-09-18T23:50:25Z' + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + .: {} + 'f:deployment.kubernetes.io/revision': {} + 'f:status': + 'f:availableReplicas': {} + 'f:conditions': + .: {} + 'k:{"type":"Available"}': + .: {} + 'f:lastTransitionTime': {} + 'f:lastUpdateTime': {} + 'f:message': {} + 'f:reason': {} + 'f:status': {} + 'f:type': {} + 'k:{"type":"Progressing"}': + .: {} + 'f:lastTransitionTime': {} + 'f:lastUpdateTime': {} + 'f:message': {} + 'f:reason': {} + 'f:status': {} + 'f:type': {} + 'f:observedGeneration': {} + 'f:readyReplicas': {} + 'f:replicas': {} + 'f:updatedReplicas': {} + manager: kube-controller-manager + operation: Update + subresource: status + time: '2022-09-23T18:30:59Z' + name: nginx-deployment + namespace: default + resourceVersion: '7492752' + uid: 731f7434-d3d9-47fa-b179-d9368a84f7c9 +spec: + progressDeadlineSeconds: 600 + replicas: 2 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: nginx + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: nginx + applications.argoproj.io/app-name: nginx + spec: + containers: + - image: 'nginx:1.23.1' + imagePullPolicy: Never + livenessProbe: + exec: + command: + - cat + - non-existent-file + failureThreshold: 3 + initialDelaySeconds: 5 + periodSeconds: 180 + successThreshold: 1 + timeoutSeconds: 1 + name: nginx + ports: + - containerPort: 80 + protocol: TCP + - containerPort: 8080 + protocol: TCP + - containerPort: 8081 + protocol: UDP + resources: + requests: + memory: 512Mi + cpu: 500m + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 2 + conditions: + - lastTransitionTime: '2022-09-18T23:50:25Z' + lastUpdateTime: '2022-09-18T23:50:26Z' + message: ReplicaSet "nginx-deployment-6d68ff5f86" has successfully progressed. + reason: NewReplicaSetAvailable + status: 'True' + type: Progressing + - lastTransitionTime: '2022-09-23T18:30:59Z' + lastUpdateTime: '2022-09-23T18:30:59Z' + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: 'True' + type: Available + observedGeneration: 1 + readyReplicas: 2 + replicas: 2 + updatedReplicas: 2 diff --git a/gitops-engine/pkg/diff/testdata/smd-deploy2-predicted-live.json b/gitops-engine/pkg/diff/testdata/smd-deploy2-predicted-live.json new file mode 100644 index 0000000000000..8f6f26874d887 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-deploy2-predicted-live.json @@ -0,0 +1,124 @@ +{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "labels": { + "app": "missing", + "applications.argoproj.io/app-name": "nginx", + "something-else": "bla" + }, + "name": "nginx-deployment", + "namespace": "default", + "managedFields": [ + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:labels": { + "f:app": {}, + "f:applications.argoproj.io/app-name": {}, + "f:something-else": {} + } + }, + "f:spec": { + "f:replicas": {}, + "f:selector": {}, + "f:template": { + "f:metadata": { + "f:labels": { + "f:app": {}, + "f:applications.argoproj.io/app-name": {} + } + }, + "f:spec": { + "f:containers": { + "k:{\"name\":\"nginx\"}": { + ".": {}, + "f:image": {}, + "f:imagePullPolicy": {}, + "f:livenessProbe": { + "f:exec": { + "f:command": {} + }, + "f:initialDelaySeconds": {}, + "f:periodSeconds": {} + }, + "f:name": {}, + "f:ports": { + "k:{\"containerPort\":80,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:protocol": {} + } + }, + "f:resources": { + "f:requests": { + "f:cpu": {}, + "f:memory": {} + } + } + } + } + } + } + } + }, + "manager": "argocd-controller", + "operation": "Apply", + "time": "2022-09-18T23:50:25Z" + } + ] + }, + "spec": { + "replicas": 2, + "selector": { + "matchLabels": { + "app": "nginx" + } + }, + "template": { + "metadata": { + "labels": { + "app": "nginx", + "applications.argoproj.io/app-name": "nginx" + } + }, + "spec": { + "containers": [ + { + "image": "nginx:1.23.1", + "imagePullPolicy": "Never", + "livenessProbe": { + "exec": { + "command": [ + "cat", + "non-existent-file" + ] + }, + "initialDelaySeconds": 5, + "periodSeconds": 180 + }, + "name": "nginx", + "ports": [ + { + "containerPort": 8081, + "protocol": "UDP" + }, + { + "containerPort": 80, + "protocol": "TCP" + } + ], + "resources": { + "requests": { + "memory": "512Mi", + "cpu": "500m" + } + } + } + ] + } + } + } +} diff --git a/gitops-engine/pkg/diff/testdata/smd-service-config-2-ports.yaml b/gitops-engine/pkg/diff/testdata/smd-service-config-2-ports.yaml new file mode 100644 index 0000000000000..157b1bc6f4b72 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-service-config-2-ports.yaml @@ -0,0 +1,18 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + argocd.argoproj.io/sync-options: ServerSideApply=true + labels: + app.kubernetes.io/instance: big-crd + name: multiple-protocol-port-svc + namespace: default +spec: + ports: + - name: rtmpk + port: 1986 + protocol: UDP + targetPort: 1986 + - name: rtmp + port: 1935 + targetPort: 1935 diff --git a/gitops-engine/pkg/diff/testdata/smd-service-config-ports.yaml b/gitops-engine/pkg/diff/testdata/smd-service-config-ports.yaml new file mode 100644 index 0000000000000..9eaa28ec37ac5 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-service-config-ports.yaml @@ -0,0 +1,29 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + argocd.argoproj.io/sync-options: ServerSideApply=true + labels: + app.kubernetes.io/instance: big-crd + name: multiple-protocol-port-svc + namespace: default +spec: + ports: + - name: rtmpk + port: 1986 + protocol: UDP + targetPort: 1986 + - name: rtmp + port: 1935 + targetPort: 1935 + - name: rtmpq + port: 1935 + protocol: UDP + targetPort: 1935 + - name: https + port: 443 + targetPort: 443 + - name: http3 + port: 443 + protocol: UDP + targetPort: 443 diff --git a/gitops-engine/pkg/diff/testdata/smd-service-config.yaml b/gitops-engine/pkg/diff/testdata/smd-service-config.yaml new file mode 100644 index 0000000000000..7b1f6325224eb --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-service-config.yaml @@ -0,0 +1,21 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + argocd.argoproj.io/sync-options: ServerSideApply=true + labels: + app.kubernetes.io/instance: big-crd + name: multiple-protocol-port-svc + namespace: default +spec: + ports: + - name: rtmpk + port: 1986 + protocol: UDP + targetPort: 1986 + - name: rtmp + port: 1935 + targetPort: 1936 + - name: https + port: 443 + targetPort: 443 diff --git a/gitops-engine/pkg/diff/testdata/smd-service-live-with-type.yaml b/gitops-engine/pkg/diff/testdata/smd-service-live-with-type.yaml new file mode 100644 index 0000000000000..23e793510ac55 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-service-live-with-type.yaml @@ -0,0 +1,110 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + argocd.argoproj.io/sync-options: ServerSideApply=true + kubectl.kubernetes.io/last-applied-configuration: > + {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{"argocd.argoproj.io/sync-options":"ServerSideApply=true"},"name":"multiple-protocol-port-svc","namespace":"default"},"spec":{"ports":[{"name":"rtmpk","port":1986,"protocol":"UDP","targetPort":1986},{"name":"rtmp","port":1935,"protocol":"TCP","targetPort":1935},{"name":"rtmpq","port":1935,"protocol":"UDP","targetPort":1935}]}} + creationTimestamp: '2022-06-24T19:37:02Z' + labels: + app.kubernetes.io/instance: big-crd + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + 'f:argocd.argoproj.io/sync-options': {} + 'f:labels': + 'f:app.kubernetes.io/instance': {} + 'f:spec': + 'f:ports': + 'k:{"port":1935,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:targetPort': {} + 'k:{"port":1986,"protocol":"UDP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:protocol': {} + 'f:targetPort': {} + 'k:{"port":443,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:targetPort': {} + 'f:type': {} + manager: argocd-controller + operation: Apply + time: '2022-06-30T16:28:09Z' + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + .: {} + 'f:kubectl.kubernetes.io/last-applied-configuration': {} + 'f:spec': + 'f:internalTrafficPolicy': {} + 'f:ports': + .: {} + 'k:{"port":1935,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:protocol': {} + 'f:targetPort': {} + 'k:{"port":1986,"protocol":"UDP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:protocol': {} + 'f:targetPort': {} + 'f:sessionAffinity': {} + manager: kubectl-client-side-apply + operation: Update + time: '2022-06-25T04:18:10Z' + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:status': + 'f:loadBalancer': + 'f:ingress': {} + manager: kube-vpnkit-forwarder + operation: Update + subresource: status + time: '2022-06-29T12:36:34Z' + name: multiple-protocol-port-svc + namespace: default + resourceVersion: '2138591' + uid: af42e800-bd33-4412-bc77-d204d298613d +spec: + clusterIP: 10.111.193.74 + clusterIPs: + - 10.111.193.74 + externalTrafficPolicy: Cluster + ipFamilies: + - IPv4 + ipFamilyPolicy: SingleStack + ports: + - name: rtmpk + nodePort: 31648 + port: 1986 + protocol: UDP + targetPort: 1986 + - name: rtmp + nodePort: 30018 + port: 1935 + protocol: TCP + targetPort: 1935 + - name: https + nodePort: 31975 + port: 443 + protocol: TCP + targetPort: 443 + sessionAffinity: None + type: NodePort +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/diff/testdata/smd-service-live.yaml b/gitops-engine/pkg/diff/testdata/smd-service-live.yaml new file mode 100644 index 0000000000000..57970850a3235 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/smd-service-live.yaml @@ -0,0 +1,83 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + argocd.argoproj.io/sync-options: ServerSideApply=true + kubectl.kubernetes.io/last-applied-configuration: > + {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{"argocd.argoproj.io/sync-options":"ServerSideApply=true"},"name":"multiple-protocol-port-svc","namespace":"default"},"spec":{"ports":[{"name":"rtmpk","port":1986,"protocol":"UDP","targetPort":1986},{"name":"rtmp","port":1935,"targetPort":1935},{"name":"https","port":443,"targetPort":443}]}} + creationTimestamp: '2022-06-24T19:37:02Z' + labels: + app.kubernetes.io/instance: big-crd + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + 'f:argocd.argoproj.io/sync-options': {} + 'f:labels': + 'f:app.kubernetes.io/instance': {} + 'f:spec': + 'f:ports': + 'k:{"port":1935,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:targetPort': {} + 'k:{"port":1986,"protocol":"UDP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:protocol': {} + 'f:targetPort': {} + 'k:{"port":443,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:targetPort': {} + manager: argocd-controller + operation: Apply + time: '2022-06-24T19:45:02Z' + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:annotations': + .: {} + 'f:argocd.argoproj.io/sync-options': {} + 'f:kubectl.kubernetes.io/last-applied-configuration': {} + 'f:spec': + 'f:internalTrafficPolicy': {} + 'f:sessionAffinity': {} + 'f:type': {} + manager: kubectl-client-side-apply + operation: Update + time: '2022-06-24T19:37:02Z' + name: multiple-protocol-port-svc + namespace: default + resourceVersion: '1825080' + uid: af42e800-bd33-4412-bc77-d204d298613d +spec: + clusterIP: 10.111.193.74 + clusterIPs: + - 10.111.193.74 + ipFamilies: + - IPv4 + ipFamilyPolicy: SingleStack + ports: + - name: rtmpk + port: 1986 + protocol: UDP + targetPort: 1986 + - name: rtmp + port: 1935 + protocol: TCP + targetPort: 1935 + - name: https + port: 443 + protocol: TCP + targetPort: 443 + sessionAffinity: None + type: ClusterIP +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/diff/testdata/spinnaker-sa-config.json b/gitops-engine/pkg/diff/testdata/spinnaker-sa-config.json new file mode 100644 index 0000000000000..9b3c82cac2a66 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/spinnaker-sa-config.json @@ -0,0 +1,15 @@ +{ + "apiVersion": "v1", + "kind": "ServiceAccount", + "metadata": { + "labels": { + "app": "spinnaker-spinnaker", + "app.kubernetes.io/instance": "spinnaker", + "chart": "spinnaker-1.1.3", + "heritage": "Tiller", + "release": "spinnaker" + }, + "name": "spinnaker-spinnaker-halyard", + "namespace": "spinnaker" + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/spinnaker-sa-live.json b/gitops-engine/pkg/diff/testdata/spinnaker-sa-live.json new file mode 100644 index 0000000000000..997d5cdd3703e --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/spinnaker-sa-live.json @@ -0,0 +1,27 @@ +{ + "apiVersion": "v1", + "kind": "ServiceAccount", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"v1\",\"kind\":\"ServiceAccount\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"spinnaker-spinnaker\",\"app.kubernetes.io/instance\":\"spinnaker\",\"chart\":\"spinnaker-1.1.3\",\"heritage\":\"Tiller\",\"release\":\"spinnaker\"},\"name\":\"spinnaker-spinnaker-halyard\",\"namespace\":\"spinnaker\"}}\n" + }, + "creationTimestamp": "2018-09-20T20:49:20Z", + "labels": { + "app": "spinnaker-spinnaker", + "app.kubernetes.io/instance": "spinnaker", + "chart": "spinnaker-1.1.3", + "heritage": "Tiller", + "release": "spinnaker" + }, + "name": "spinnaker-spinnaker-halyard", + "namespace": "spinnaker", + "resourceVersion": "12102423", + "selfLink": "/api/v1/namespaces/spinnaker/serviceaccounts/spinnaker-spinnaker-halyard", + "uid": "a5a9401b-bd16-11e8-bbd2-42010a8a00bb" + }, + "secrets": [ + { + "name": "spinnaker-spinnaker-halyard-token-7m6xs" + } + ] + } \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-config.yaml b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-config.yaml new file mode 100644 index 0000000000000..cdc87cd3dabb9 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-config.yaml @@ -0,0 +1,36 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: nested-test-deployment + namespace: default + labels: + app: nested-test + applications.argoproj.io/app-name: nested-app +spec: + replicas: 1 + selector: + matchLabels: + app: nested-test + template: + metadata: + labels: + app: nested-test + spec: + automountServiceAccountToken: false + containers: + - name: main-container + image: 'nginx:latest' + ports: + - containerPort: 80 + name: http + protocol: TCP + - containerPort: 443 + name: https + env: + - name: ENV_VAR1 + value: "value1" + - name: ENV_VAR2 + value: "value2" + resources: + limits: + memory: 100Mi \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-live.yaml b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-live.yaml new file mode 100644 index 0000000000000..d62993694e8e2 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-live.yaml @@ -0,0 +1,70 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: nested-test-deployment + namespace: default + labels: + app: nested-test + applications.argoproj.io/app-name: nested-app + annotations: + deployment.kubernetes.io/revision: '1' + managedFields: + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + f:metadata: + f:labels: + f:app: {} + f:applications.argoproj.io/app-name: {} + f:spec: + f:replicas: {} + f:selector: {} + f:template: + f:metadata: + f:labels: + f:app: {} + f:spec: + f:containers: + k:{"name":"main-container"}: + .: {} + f:image: {} + f:name: {} + f:ports: + .: {} + k:{"containerPort":80,"protocol":"TCP"}: + .: {} + f:containerPort: {} + f:name: {} + f:protocol: {} + f:env: + .: {} + k:{"name":"ENV_VAR1"}: + .: {} + f:name: {} + f:value: {} + manager: argocd-controller + operation: Apply +spec: + replicas: 1 + selector: + matchLabels: + app: nested-test + template: + metadata: + labels: + app: nested-test + spec: + automountServiceAccountToken: false + containers: + - name: main-container + image: 'nginx:latest' + ports: + - containerPort: 80 + name: http + protocol: TCP + env: + - name: ENV_VAR1 + value: "value1" + resources: + limits: + memory: "100Mi" \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-predicted-live.json b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-predicted-live.json new file mode 100644 index 0000000000000..cc269aa3db7a7 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-nested-predicted-live.json @@ -0,0 +1,131 @@ +{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "name": "nested-test-deployment", + "namespace": "default", + "labels": { + "app": "nested-test", + "applications.argoproj.io/app-name": "nested-app" + }, + "annotations": { + "deployment.kubernetes.io/revision": "2" + }, + "managedFields": [ + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:labels": { + "f:app": {}, + "f:applications.argoproj.io/app-name": {} + } + }, + "f:spec": { + "f:replicas": {}, + "f:selector": {}, + "f:template": { + "f:metadata": { + "f:labels": { + "f:app": {} + } + }, + "f:spec": { + "f:containers": { + "k:{\"name\":\"main-container\"}": { + ".": {}, + "f:image": {}, + "f:name": {}, + "f:ports": { + ".": {}, + "k:{\"containerPort\":80,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {}, + "f:protocol": {} + }, + "k:{\"containerPort\":443,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {}, + "f:protocol": {} + } + }, + "f:env": { + ".": {}, + "k:{\"name\":\"ENV_VAR1\"}": { + ".": {}, + "f:name": {}, + "f:value": {} + }, + "k:{\"name\":\"ENV_VAR2\"}": { + ".": {}, + "f:name": {}, + "f:value": {} + } + } + } + } + } + } + } + }, + "manager": "argocd-controller", + "operation": "Apply", + "time": "2023-12-19T00:00:00Z" + } + ] + }, + "spec": { + "replicas": 1, + "selector": { + "matchLabels": { + "app": "nested-test" + } + }, + "template": { + "metadata": { + "labels": { + "app": "nested-test" + } + }, + "spec": { + "automountServiceAccountToken": false, + "containers": [ + { + "name": "main-container", + "image": "nginx:latest", + "ports": [ + { + "containerPort": 80, + "name": "http", + "protocol": "TCP" + }, + { + "containerPort": 443, + "name": "https", + "protocol": "TCP" + } + ], + "env": [ + { + "name": "ENV_VAR1", + "value": "value1" + }, + { + "name": "ENV_VAR2", + "value": "value2" + } + ], + "resources": { + "limits": { + "memory": "100Mi" + } + } + } + ] + } + } + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-config.yaml b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-config.yaml new file mode 100644 index 0000000000000..7375f2685ce3d --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-config.yaml @@ -0,0 +1,30 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: manual-apply-test-deployment + namespace: default + labels: + app: manual-apply-app + applications.argoproj.io/app-name: manual-apply-app +spec: + replicas: 1 + selector: + matchLabels: + app: manual-apply-test + template: + metadata: + labels: + app: manual-apply-test + spec: + automountServiceAccountToken: false + containers: + - name: main-container + image: 'nginx:latest' + ports: + - containerPort: 80 + name: http + - containerPort: 40 + name: https + resources: + limits: + memory: "100Mi" \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-live.yaml b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-live.yaml new file mode 100644 index 0000000000000..9be749b5e7981 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-live.yaml @@ -0,0 +1,181 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: "4" + creationTimestamp: "2025-02-25T00:20:45Z" + generation: 4 + labels: + app: manual-apply-app + applications.argoproj.io/app-name: manual-apply-app + managedFields: + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + f:metadata: + f:annotations: {} + f:labels: + .: {} + f:app: {} + f:applications.argoproj.io/app-name: {} + f:spec: + f:progressDeadlineSeconds: {} + f:replicas: {} + f:revisionHistoryLimit: {} + f:selector: {} + f:strategy: + f:rollingUpdate: + .: {} + f:maxSurge: {} + f:maxUnavailable: {} + f:type: {} + f:template: + f:metadata: + f:labels: + .: {} + f:app: {} + f:spec: + f:automountServiceAccountToken: {} + f:containers: + k:{"name":"main-container"}: + .: {} + f:image: {} + f:imagePullPolicy: {} + f:name: {} + f:ports: + .: {} + k:{"containerPort":80,"protocol":"TCP"}: + .: {} + f:containerPort: {} + f:name: {} + f:protocol: {} + f:resources: + .: {} + f:limits: + .: {} + f:memory: {} + f:terminationMessagePath: {} + f:terminationMessagePolicy: {} + f:dnsPolicy: {} + f:restartPolicy: {} + f:schedulerName: {} + f:securityContext: {} + f:terminationGracePeriodSeconds: {} + manager: argocd-controller + operation: Update + time: "2025-02-25T01:19:32Z" + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + f:metadata: + f:annotations: + f:kubectl.kubernetes.io/last-applied-configuration: {} + f:spec: + f:template: + f:spec: + f:containers: + k:{"name":"idle"}: + .: {} + f:image: {} + f:imagePullPolicy: {} + f:name: {} + f:ports: + .: {} + k:{"containerPort":8080,"protocol":"TCP"}: + .: {} + f:containerPort: {} + f:name: {} + f:protocol: {} + f:resources: {} + f:terminationMessagePath: {} + f:terminationMessagePolicy: {} + manager: kubectl-client-side-apply + operation: Update + time: "2025-02-25T01:29:34Z" + - apiVersion: apps/v1 + fieldsType: FieldsV1 + fieldsV1: + f:metadata: + f:annotations: + f:deployment.kubernetes.io/revision: {} + f:status: + f:availableReplicas: {} + f:conditions: + .: {} + k:{"type":"Available"}: + .: {} + f:lastTransitionTime: {} + f:lastUpdateTime: {} + f:message: {} + f:reason: {} + f:status: {} + f:type: {} + k:{"type":"Progressing"}: + .: {} + f:lastTransitionTime: {} + f:lastUpdateTime: {} + f:message: {} + f:reason: {} + f:status: {} + f:type: {} + f:observedGeneration: {} + f:readyReplicas: {} + f:replicas: {} + f:updatedReplicas: {} + manager: kube-controller-manager + operation: Update + subresource: status + time: "2025-02-25T01:29:44Z" + name: manual-apply-test-deployment + namespace: default + resourceVersion: "46835" + uid: c2ff066f-cbbd-408d-a015-85f1b6332193 +spec: + progressDeadlineSeconds: 600 + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: manual-apply-test + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: manual-apply-test + spec: + automountServiceAccountToken: false + containers: + - image: nginx:latest + imagePullPolicy: Always + name: main-container + ports: + - containerPort: 80 + name: http + protocol: TCP + resources: + limits: + memory: 100Mi + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + - image: spurin/idle:latest + imagePullPolicy: Always + name: idle + ports: + - containerPort: 8080 + name: web + protocol: TCP + resources: + limits: + memory: 100Mi + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-predicted-live.json b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-predicted-live.json new file mode 100644 index 0000000000000..e9c1b2869f82c --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-deploy-with-manual-apply-predicted-live.json @@ -0,0 +1,310 @@ +{ + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "annotations": { + "deployment.kubernetes.io/revision": "4", + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"apps/v1\",\"kind\":\"Deployment\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"manual-apply-app\",\"applications.argoproj.io/app-name\":\"manual-apply-app\"},\"name\":\"manual-apply-test-deployment\",\"namespace\":\"default\"},\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"app\":\"manual-apply-test\"}},\"template\":{\"metadata\":{\"labels\":{\"app\":\"manual-apply-test\"}},\"spec\":{\"automountServiceAccountToken\":false,\"containers\":[{\"image\":\"nginx:latest\",\"name\":\"main-container\",\"ports\":[{\"containerPort\":80,\"name\":\"http\"}],\"resources\":{\"limits\":{\"memory\":\"100Mi\"}}},{\"image\":\"spurin/idle:latest\",\"name\":\"idle\",\"ports\":[{\"containerPort\":8080,\"name\":\"web\",\"protocol\":\"TCP\"}]}]}}}}\n" + }, + "creationTimestamp": "2025-02-25T00:20:45Z", + "generation": 5, + "labels": { + "app": "manual-apply-app", + "applications.argoproj.io/app-name": "manual-apply-app", + "mutation-test": "FROM-MUTATION-WEBHOOK" + }, + "managedFields": [ + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:labels": { + "f:app": {}, + "f:applications.argoproj.io/app-name": {} + } + }, + "f:spec": { + "f:replicas": {}, + "f:selector": {}, + "f:template": { + "f:metadata": { + "f:labels": { + "f:app": {} + } + }, + "f:spec": { + "f:automountServiceAccountToken": {}, + "f:containers": { + "k:{\"name\":\"main-container\"}": { + ".": {}, + "f:image": {}, + "f:name": {}, + "f:ports": { + "k:{\"containerPort\":40,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {} + }, + "k:{\"containerPort\":80,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {} + } + }, + "f:resources": { + "f:limits": { + "f:memory": {} + } + } + } + } + } + } + } + }, + "manager": "argocd-controller", + "operation": "Apply", + "time": "2025-02-25T01:31:03Z" + }, + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:annotations": {}, + "f:labels": { + ".": {}, + "f:app": {}, + "f:applications.argoproj.io/app-name": {} + } + }, + "f:spec": { + "f:progressDeadlineSeconds": {}, + "f:replicas": {}, + "f:revisionHistoryLimit": {}, + "f:selector": {}, + "f:strategy": { + "f:rollingUpdate": { + ".": {}, + "f:maxSurge": {}, + "f:maxUnavailable": {} + }, + "f:type": {} + }, + "f:template": { + "f:metadata": { + "f:labels": { + ".": {}, + "f:app": {} + } + }, + "f:spec": { + "f:automountServiceAccountToken": {}, + "f:containers": { + "k:{\"name\":\"main-container\"}": { + ".": {}, + "f:image": {}, + "f:imagePullPolicy": {}, + "f:name": {}, + "f:ports": { + ".": {}, + "k:{\"containerPort\":80,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {}, + "f:protocol": {} + } + }, + "f:resources": { + ".": {}, + "f:limits": { + ".": {}, + "f:memory": {} + } + }, + "f:terminationMessagePath": {}, + "f:terminationMessagePolicy": {} + } + }, + "f:dnsPolicy": {}, + "f:restartPolicy": {}, + "f:schedulerName": {}, + "f:securityContext": {}, + "f:terminationGracePeriodSeconds": {} + } + } + } + }, + "manager": "argocd-controller", + "operation": "Update", + "time": "2025-02-25T01:19:32Z" + }, + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:annotations": { + "f:kubectl.kubernetes.io/last-applied-configuration": {} + } + }, + "f:spec": { + "f:template": { + "f:spec": { + "f:containers": { + "k:{\"name\":\"idle\"}": { + ".": {}, + "f:image": {}, + "f:imagePullPolicy": {}, + "f:name": {}, + "f:ports": { + ".": {}, + "k:{\"containerPort\":8080,\"protocol\":\"TCP\"}": { + ".": {}, + "f:containerPort": {}, + "f:name": {}, + "f:protocol": {} + } + }, + "f:resources": {}, + "f:terminationMessagePath": {}, + "f:terminationMessagePolicy": {} + } + } + } + } + } + }, + "manager": "kubectl-client-side-apply", + "operation": "Update", + "time": "2025-02-25T01:29:34Z" + }, + { + "apiVersion": "apps/v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:annotations": { + "f:deployment.kubernetes.io/revision": {} + } + }, + "f:status": { + "f:availableReplicas": {}, + "f:conditions": { + ".": {}, + "k:{\"type\":\"Available\"}": { + ".": {}, + "f:lastTransitionTime": {}, + "f:lastUpdateTime": {}, + "f:message": {}, + "f:reason": {}, + "f:status": {}, + "f:type": {} + }, + "k:{\"type\":\"Progressing\"}": { + ".": {}, + "f:lastTransitionTime": {}, + "f:lastUpdateTime": {}, + "f:message": {}, + "f:reason": {}, + "f:status": {}, + "f:type": {} + } + }, + "f:observedGeneration": {}, + "f:readyReplicas": {}, + "f:replicas": {}, + "f:updatedReplicas": {} + } + }, + "manager": "kube-controller-manager", + "operation": "Update", + "subresource": "status", + "time": "2025-02-25T01:29:44Z" + } + ], + "name": "manual-apply-test-deployment", + "namespace": "default", + "resourceVersion": "46835", + "uid": "c2ff066f-cbbd-408d-a015-85f1b6332193" + }, + "spec": { + "progressDeadlineSeconds": 600, + "replicas": 1, + "revisionHistoryLimit": 10, + "selector": { + "matchLabels": { + "app": "manual-apply-test" + } + }, + "strategy": { + "rollingUpdate": { + "maxSurge": "25%", + "maxUnavailable": "25%" + }, + "type": "RollingUpdate" + }, + "template": { + "metadata": { + "creationTimestamp": null, + "labels": { + "app": "manual-apply-test" + } + }, + "spec": { + "automountServiceAccountToken": false, + "containers": [ + { + "image": "nginx:latest", + "imagePullPolicy": "Always", + "name": "main-container", + "ports": [ + { + "containerPort": 80, + "name": "http", + "protocol": "TCP" + }, + { + "containerPort": 40, + "name": "https", + "protocol": "TCP" + } + ], + "resources": { + "limits": { + "memory": "100Mi" + } + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File" + }, + { + "image": "spurin/idle:latest", + "imagePullPolicy": "Always", + "name": "idle", + "ports": [ + { + "containerPort": 8080, + "name": "web", + "protocol": "TCP" + } + ], + "resources": { + "limits": { + "memory": "100Mi" + } + }, + "terminationMessagePath": "/dev/termination-log", + "terminationMessagePolicy": "File" + } + ], + "dnsPolicy": "ClusterFirst", + "restartPolicy": "Always", + "schedulerName": "default-scheduler", + "securityContext": {}, + "terminationGracePeriodSeconds": 30 + } + } + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-service-config.yaml b/gitops-engine/pkg/diff/testdata/ssd-service-config.yaml new file mode 100644 index 0000000000000..ca0678ffc3178 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-service-config.yaml @@ -0,0 +1,16 @@ +apiVersion: v1 +kind: Service +metadata: + labels: + app.kubernetes.io/instance: httpbin + name: httpbin-svc + namespace: httpbin +spec: + ports: + - name: http-port + port: 7777 + targetPort: 80 + - name: test + port: 333 + selector: + app: httpbin diff --git a/gitops-engine/pkg/diff/testdata/ssd-service-live.yaml b/gitops-engine/pkg/diff/testdata/ssd-service-live.yaml new file mode 100644 index 0000000000000..98d01a709cb96 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-service-live.yaml @@ -0,0 +1,55 @@ +apiVersion: v1 +kind: Service +metadata: + creationTimestamp: '2023-12-18T00:34:22Z' + labels: + app.kubernetes.io/instance: httpbin + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + 'f:metadata': + 'f:labels': + 'f:app.kubernetes.io/instance': {} + 'f:spec': + 'f:ports': + 'k:{"port":333,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'k:{"port":7777,"protocol":"TCP"}': + .: {} + 'f:name': {} + 'f:port': {} + 'f:targetPort': {} + 'f:selector': {} + manager: argocd-controller + operation: Apply + time: '2023-12-18T00:34:22Z' + name: httpbin-svc + namespace: httpbin + resourceVersion: '2836' + uid: 0e898e6f-c275-476d-9b4f-5e96072cc129 +spec: + clusterIP: 10.43.223.115 + clusterIPs: + - 10.43.223.115 + internalTrafficPolicy: Cluster + ipFamilies: + - IPv4 + ipFamilyPolicy: SingleStack + ports: + - name: http-port + port: 7777 + protocol: TCP + targetPort: 80 + - name: test + port: 333 + protocol: TCP + targetPort: 333 + selector: + app: httpbin + sessionAffinity: None + type: ClusterIP +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/diff/testdata/ssd-service-predicted-live.json b/gitops-engine/pkg/diff/testdata/ssd-service-predicted-live.json new file mode 100644 index 0000000000000..ca1323f31c393 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-service-predicted-live.json @@ -0,0 +1,74 @@ +{ + "apiVersion": "v1", + "kind": "Service", + "metadata": { + "creationTimestamp": "2023-12-18T00:34:22Z", + "labels": { + "event": "FROM-MUTATION-WEBHOOK" + }, + "managedFields": [ + { + "apiVersion": "v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:spec": { + "f:ports": { + "k:{\"port\":333,\"protocol\":\"TCP\"}": { + ".": {}, + "f:name": {}, + "f:port": {} + }, + "k:{\"port\":7777,\"protocol\":\"TCP\"}": { + ".": {}, + "f:name": {}, + "f:port": {}, + "f:targetPort": {} + } + }, + "f:selector": {} + } + }, + "manager": "argocd-controller", + "operation": "Apply", + "time": "2023-12-18T00:38:28Z" + } + ], + "name": "httpbin-svc", + "namespace": "httpbin", + "resourceVersion": "2836", + "uid": "0e898e6f-c275-476d-9b4f-5e96072cc129" + }, + "spec": { + "clusterIP": "10.43.223.115", + "clusterIPs": [ + "10.43.223.115" + ], + "internalTrafficPolicy": "Cluster", + "ipFamilies": [ + "IPv4" + ], + "ipFamilyPolicy": "SingleStack", + "ports": [ + { + "name": "http-port", + "port": 7777, + "protocol": "TCP", + "targetPort": 80 + }, + { + "name": "test", + "port": 333, + "protocol": "TCP", + "targetPort": 333 + } + ], + "selector": { + "app": "httpbin" + }, + "sessionAffinity": "None", + "type": "ClusterIP" + }, + "status": { + "loadBalancer": {} + } +} diff --git a/gitops-engine/pkg/diff/testdata/ssd-svc-label-live.yaml b/gitops-engine/pkg/diff/testdata/ssd-svc-label-live.yaml new file mode 100644 index 0000000000000..175d6c051c7b0 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-svc-label-live.yaml @@ -0,0 +1,50 @@ +apiVersion: v1 +kind: Service +metadata: + creationTimestamp: "2025-05-16T19:01:22Z" + labels: + app.kubernetes.io/instance: httpbin + delete-me: delete-value + managedFields: + - apiVersion: v1 + fieldsType: FieldsV1 + fieldsV1: + f:metadata: + f:labels: + f:app.kubernetes.io/instance: {} + f:delete-me: {} + f:spec: + f:ports: + k:{"port":7777,"protocol":"TCP"}: + .: {} + f:name: {} + f:port: {} + f:protocol: {} + f:targetPort: {} + f:selector: {} + manager: argocd-controller + operation: Apply + time: "2025-05-16T19:01:22Z" + name: httpbin-svc + namespace: httpbin + resourceVersion: "159005" + uid: 61a7a0c2-d973-4333-bbd6-c06ba1c00190 +spec: + clusterIP: 10.96.59.144 + clusterIPs: + - 10.96.59.144 + internalTrafficPolicy: Cluster + ipFamilies: + - IPv4 + ipFamilyPolicy: SingleStack + ports: + - name: http-port + port: 7777 + protocol: TCP + targetPort: 80 + selector: + app: httpbin + sessionAffinity: None + type: ClusterIP +status: + loadBalancer: {} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-config.yaml b/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-config.yaml new file mode 100644 index 0000000000000..842bcc7f997d8 --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-config.yaml @@ -0,0 +1,15 @@ +apiVersion: v1 +kind: Service +metadata: + labels: + app.kubernetes.io/instance: httpbin + name: httpbin-svc + namespace: httpbin +spec: + ports: + - name: http-port + port: 7777 + protocol: TCP + targetPort: 80 + selector: + app: httpbin \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-predicted-live.json b/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-predicted-live.json new file mode 100644 index 0000000000000..69e88f055768c --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/ssd-svc-no-label-predicted-live.json @@ -0,0 +1,69 @@ +{ + "apiVersion": "v1", + "kind": "Service", + "metadata": { + "creationTimestamp": "2025-05-16T19:01:22Z", + "labels": { + "app.kubernetes.io/instance": "httpbin" + }, + "managedFields": [ + { + "apiVersion": "v1", + "fieldsType": "FieldsV1", + "fieldsV1": { + "f:metadata": { + "f:labels": { + "f:app.kubernetes.io/instance": {} + } + }, + "f:spec": { + "f:ports": { + "k:{\"port\":7777,\"protocol\":\"TCP\"}": { + ".": {}, + "f:name": {}, + "f:port": {}, + "f:protocol": {}, + "f:targetPort": {} + } + }, + "f:selector": {} + } + }, + "manager": "argocd-controller", + "operation": "Apply", + "time": "2025-05-16T19:02:57Z" + } + ], + "name": "httpbin-svc", + "namespace": "httpbin", + "resourceVersion": "159005", + "uid": "61a7a0c2-d973-4333-bbd6-c06ba1c00190" + }, + "spec": { + "clusterIP": "10.96.59.144", + "clusterIPs": [ + "10.96.59.144" + ], + "internalTrafficPolicy": "Cluster", + "ipFamilies": [ + "IPv4" + ], + "ipFamilyPolicy": "SingleStack", + "ports": [ + { + "name": "http-port", + "port": 7777, + "protocol": "TCP", + "targetPort": 80 + } + ], + "selector": { + "app": "httpbin" + }, + "sessionAffinity": "None", + "type": "ClusterIP" + }, + "status": { + "loadBalancer": {} + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/wordpress-config.json b/gitops-engine/pkg/diff/testdata/wordpress-config.json new file mode 100644 index 0000000000000..23e675526fa1f --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/wordpress-config.json @@ -0,0 +1,18 @@ +{ + "apiVersion": "v1", + "kind": "Secret", + "metadata": { + "name": "wordpress-wordpress", + "labels": { + "app": "wordpress-wordpress", + "chart": "wordpress-5.0.1", + "release": "wordpress", + "heritage": "Tiller" + } + }, + "type": "Opaque", + "data": { + "wordpress-password": "Skt2T0tjMk5PdQ==", + "smtp-password": "" + } +} \ No newline at end of file diff --git a/gitops-engine/pkg/diff/testdata/wordpress-live.json b/gitops-engine/pkg/diff/testdata/wordpress-live.json new file mode 100644 index 0000000000000..cedccd98493ba --- /dev/null +++ b/gitops-engine/pkg/diff/testdata/wordpress-live.json @@ -0,0 +1,26 @@ +{ + "apiVersion": "v1", + "data": { + "smtp-password": null, + "wordpress-password": "Skt2T0tjMk5PdQ==" + }, + "kind": "Secret", + "metadata": { + "annotations": { + "kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"v1\",\"data\":{\"smtp-password\":\"\",\"wordpress-password\":\"Xkt2T0tjMk5PdQ==\"},\"kind\":\"Secret\",\"metadata\":{\"annotations\":{},\"labels\":{\"app\":\"wordpress-wordpress\",\"chart\":\"wordpress-5.0.1\",\"heritage\":\"Tiller\",\"release\":\"wordpress\"},\"name\":\"wordpress-wordpress\",\"namespace\":\"argocd\"},\"type\":\"Opaque\"}\n" + }, + "creationTimestamp": "2018-12-19T09:15:40Z", + "labels": { + "app": "wordpress-wordpress", + "chart": "wordpress-5.0.1", + "heritage": "Tiller", + "release": "wordpress" + }, + "name": "wordpress-wordpress", + "namespace": "argocd", + "resourceVersion": "27442", + "selfLink": "/api/v1/namespaces/argocd/secrets/wordpress-wordpress", + "uid": "a782f882-036e-11e9-92c4-ba8ba592c12d" + }, + "type": "Opaque" +} \ No newline at end of file diff --git a/gitops-engine/pkg/engine/engine.go b/gitops-engine/pkg/engine/engine.go new file mode 100644 index 0000000000000..01e5561b193e2 --- /dev/null +++ b/gitops-engine/pkg/engine/engine.go @@ -0,0 +1,129 @@ +/* +The package provides high-level interface that leverages "pkg/cache", "pkg/sync", "pkg/health" and "pkg/diff" packages +and "implements" GitOps. + +Example + +The https://github.com/argoproj/gitops-engine/tree/master/agent demonstrates how to use the engine. +*/ + +package engine + +import ( + "context" + "fmt" + "time" + + "github.com/go-logr/logr" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/rest" + + "github.com/argoproj/gitops-engine/pkg/cache" + "github.com/argoproj/gitops-engine/pkg/diff" + "github.com/argoproj/gitops-engine/pkg/sync" + "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +const ( + operationRefreshTimeout = time.Second * 1 +) + +type StopFunc func() + +type GitOpsEngine interface { + // Run initializes engine + Run() (StopFunc, error) + // Synchronizes resources in the cluster + Sync(ctx context.Context, resources []*unstructured.Unstructured, isManaged func(r *cache.Resource) bool, revision string, namespace string, opts ...sync.SyncOpt) ([]common.ResourceSyncResult, error) +} + +type gitOpsEngine struct { + config *rest.Config + cache cache.ClusterCache + kubectl kube.Kubectl + log logr.Logger +} + +// NewEngine creates new instances of the GitOps engine +func NewEngine(config *rest.Config, clusterCache cache.ClusterCache, opts ...Option) GitOpsEngine { + o := applyOptions(opts) + return &gitOpsEngine{ + config: config, + cache: clusterCache, + kubectl: o.kubectl, + log: o.log, + } +} + +func (e *gitOpsEngine) Run() (StopFunc, error) { + err := e.cache.EnsureSynced() + if err != nil { + return nil, fmt.Errorf("failed to ensure the cache is synced: %w", err) + } + + return func() { + e.cache.Invalidate() + }, nil +} + +func (e *gitOpsEngine) Sync(ctx context.Context, + resources []*unstructured.Unstructured, + isManaged func(r *cache.Resource) bool, + revision string, + namespace string, + opts ...sync.SyncOpt, +) ([]common.ResourceSyncResult, error) { + managedResources, err := e.cache.GetManagedLiveObjs(resources, isManaged) + if err != nil { + return nil, fmt.Errorf("failed to get managed live objects: %w", err) + } + result := sync.Reconcile(resources, managedResources, namespace, e.cache) + diffRes, err := diff.DiffArray(result.Target, result.Live, diff.WithLogr(e.log)) + if err != nil { + return nil, fmt.Errorf("failed to diff objects: %w", err) + } + opts = append(opts, sync.WithSkipHooks(!diffRes.Modified)) + syncCtx, cleanup, err := sync.NewSyncContext(revision, result, e.config, e.config, e.kubectl, namespace, e.cache.GetOpenAPISchema(), opts...) + if err != nil { + return nil, fmt.Errorf("failed to create sync context: %w", err) + } + defer cleanup() + + resUpdated := make(chan bool) + resIgnore := make(chan struct{}) + unsubscribe := e.cache.OnResourceUpdated(func(newRes *cache.Resource, oldRes *cache.Resource, _ map[kube.ResourceKey]*cache.Resource) { + var key kube.ResourceKey + if newRes != nil { + key = newRes.ResourceKey() + } else { + key = oldRes.ResourceKey() + } + if _, ok := managedResources[key]; ok { + select { + case resUpdated <- true: + case <-resIgnore: + } + } + }) + defer close(resIgnore) + defer unsubscribe() + for { + syncCtx.Sync() + phase, message, resources := syncCtx.GetState() + if phase.Completed() { + if phase == common.OperationError { + err = fmt.Errorf("sync operation failed: %s", message) + } + return resources, err + } + select { + case <-ctx.Done(): + syncCtx.Terminate() + //nolint:wrapcheck // don't wrap context errors + return resources, ctx.Err() + case <-time.After(operationRefreshTimeout): + case <-resUpdated: + } + } +} diff --git a/gitops-engine/pkg/engine/engine_options.go b/gitops-engine/pkg/engine/engine_options.go new file mode 100644 index 0000000000000..d49263dc6d038 --- /dev/null +++ b/gitops-engine/pkg/engine/engine_options.go @@ -0,0 +1,56 @@ +package engine + +import ( + "github.com/go-logr/logr" + "k8s.io/klog/v2/textlogger" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +type Option func(*options) + +type options struct { + log logr.Logger + kubectl kube.Kubectl +} + +func applyOptions(opts []Option) options { + log := textlogger.NewLogger(textlogger.NewConfig()) + o := options{ + log: log, + kubectl: &kube.KubectlCmd{ + Log: log, + Tracer: tracing.NopTracer{}, + }, + } + for _, opt := range opts { + opt(&o) + } + return o +} + +func WithLogr(log logr.Logger) Option { + return func(o *options) { + o.log = log + if kcmd, ok := o.kubectl.(*kube.KubectlCmd); ok { + kcmd.Log = log + } + } +} + +// SetTracer sets the tracer to use. +func SetTracer(tracer tracing.Tracer) Option { + return func(o *options) { + if kcmd, ok := o.kubectl.(*kube.KubectlCmd); ok { + kcmd.Tracer = tracer + } + } +} + +// WithKubectl allows to override kubectl wrapper implementation. +func WithKubectl(kubectl kube.Kubectl) Option { + return func(o *options) { + o.kubectl = kubectl + } +} diff --git a/gitops-engine/pkg/health/health.go b/gitops-engine/pkg/health/health.go new file mode 100644 index 0000000000000..ef09023f41bb5 --- /dev/null +++ b/gitops-engine/pkg/health/health.go @@ -0,0 +1,152 @@ +package health + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/argoproj/gitops-engine/pkg/sync/hook" + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +// Represents resource health status +type HealthStatusCode string + +const ( + // Indicates that health assessment failed and actual health status is unknown + HealthStatusUnknown HealthStatusCode = "Unknown" + // Progressing health status means that resource is not healthy but still have a chance to reach healthy state + HealthStatusProgressing HealthStatusCode = "Progressing" + // Resource is 100% healthy + HealthStatusHealthy HealthStatusCode = "Healthy" + // Assigned to resources that are suspended or paused. The typical example is a + // [suspended](https://kubernetes.io/docs/tasks/job/automated-tasks-with-cron-jobs/#suspend) CronJob. + HealthStatusSuspended HealthStatusCode = "Suspended" + // Degrade status is used if resource status indicates failure or resource could not reach healthy state + // within some timeout. + HealthStatusDegraded HealthStatusCode = "Degraded" + // Indicates that resource is missing in the cluster. + HealthStatusMissing HealthStatusCode = "Missing" +) + +// Implements custom health assessment that overrides built-in assessment +type HealthOverride interface { + GetResourceHealth(obj *unstructured.Unstructured) (*HealthStatus, error) +} + +// Holds health assessment results +type HealthStatus struct { + Status HealthStatusCode `json:"status,omitempty"` + Message string `json:"message,omitempty"` +} + +// healthOrder is a list of health codes in order of most healthy to least healthy +var healthOrder = []HealthStatusCode{ + HealthStatusHealthy, + HealthStatusSuspended, + HealthStatusProgressing, + HealthStatusMissing, + HealthStatusDegraded, + HealthStatusUnknown, +} + +// IsWorse returns whether or not the new health status code is a worse condition than the current +func IsWorse(current, new HealthStatusCode) bool { + currentIndex := 0 + newIndex := 0 + for i, code := range healthOrder { + if current == code { + currentIndex = i + } + if new == code { + newIndex = i + } + } + return newIndex > currentIndex +} + +// GetResourceHealth returns the health of a k8s resource +func GetResourceHealth(obj *unstructured.Unstructured, healthOverride HealthOverride) (health *HealthStatus, err error) { + if obj.GetDeletionTimestamp() != nil && !hook.HasHookFinalizer(obj) { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Pending deletion", + }, nil + } + + if healthOverride != nil { + health, err := healthOverride.GetResourceHealth(obj) + if err != nil { + health = &HealthStatus{ + Status: HealthStatusUnknown, + Message: err.Error(), + } + return health, fmt.Errorf("failed to get resource health for %s/%s: %w", obj.GetNamespace(), obj.GetName(), err) + } + if health != nil { + return health, nil + } + } + + if healthCheck := GetHealthCheckFunc(obj.GroupVersionKind()); healthCheck != nil { + if health, err = healthCheck(obj); err != nil { + health = &HealthStatus{ + Status: HealthStatusUnknown, + Message: err.Error(), + } + } + } + return health, err +} + +// GetHealthCheckFunc returns built-in health check function or nil if health check is not supported +func GetHealthCheckFunc(gvk schema.GroupVersionKind) func(obj *unstructured.Unstructured) (*HealthStatus, error) { + switch gvk.Group { + case "apps": + switch gvk.Kind { + case kube.DeploymentKind: + return getDeploymentHealth + case kube.StatefulSetKind: + return getStatefulSetHealth + case kube.ReplicaSetKind: + return getReplicaSetHealth + case kube.DaemonSetKind: + return getDaemonSetHealth + } + case "extensions": + if gvk.Kind == kube.IngressKind { + return getIngressHealth + } + case "argoproj.io": + if gvk.Kind == "Workflow" { + return getArgoWorkflowHealth + } + case "apiregistration.k8s.io": + if gvk.Kind == kube.APIServiceKind { + return getAPIServiceHealth + } + case "networking.k8s.io": + if gvk.Kind == kube.IngressKind { + return getIngressHealth + } + case "": + switch gvk.Kind { + case kube.ServiceKind: + return getServiceHealth + case kube.PersistentVolumeClaimKind: + return getPVCHealth + case kube.PodKind: + return getPodHealth + } + case "batch": + if gvk.Kind == kube.JobKind { + return getJobHealth + } + case "autoscaling": + if gvk.Kind == kube.HorizontalPodAutoscalerKind { + return getHPAHealth + } + } + return nil +} diff --git a/gitops-engine/pkg/health/health_apiservice.go b/gitops-engine/pkg/health/health_apiservice.go new file mode 100644 index 0000000000000..8def46256db66 --- /dev/null +++ b/gitops-engine/pkg/health/health_apiservice.go @@ -0,0 +1,76 @@ +package health + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + apiregistrationv1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" + apiregistrationv1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getAPIServiceHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case apiregistrationv1.SchemeGroupVersion.WithKind(kube.APIServiceKind): + var apiService apiregistrationv1.APIService + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &apiService) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured APIService to typed: %w", err) + } + return getApiregistrationv1APIServiceHealth(&apiService) + case apiregistrationv1beta1.SchemeGroupVersion.WithKind(kube.APIServiceKind): + var apiService apiregistrationv1beta1.APIService + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &apiService) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured APIService to typed: %w", err) + } + return getApiregistrationv1beta1APIServiceHealth(&apiService) + default: + return nil, fmt.Errorf("unsupported APIService GVK: %s", gvk) + } +} + +func getApiregistrationv1APIServiceHealth(apiservice *apiregistrationv1.APIService) (*HealthStatus, error) { + for _, c := range apiservice.Status.Conditions { + if c.Type == apiregistrationv1.Available { + if c.Status == apiregistrationv1.ConditionTrue { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("%s: %s", c.Reason, c.Message), + }, nil + } + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("%s: %s", c.Reason, c.Message), + }, nil + } + } + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting to be processed", + }, nil +} + +func getApiregistrationv1beta1APIServiceHealth(apiservice *apiregistrationv1beta1.APIService) (*HealthStatus, error) { + for _, c := range apiservice.Status.Conditions { + if c.Type == apiregistrationv1beta1.Available { + if c.Status == apiregistrationv1beta1.ConditionTrue { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("%s: %s", c.Reason, c.Message), + }, nil + } + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("%s: %s", c.Reason, c.Message), + }, nil + } + } + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting to be processed", + }, nil +} diff --git a/gitops-engine/pkg/health/health_argo.go b/gitops-engine/pkg/health/health_argo.go new file mode 100644 index 0000000000000..6a1684858c5a6 --- /dev/null +++ b/gitops-engine/pkg/health/health_argo.go @@ -0,0 +1,32 @@ +package health + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +type nodePhase string + +// Workflow and node statuses +// See: https://github.com/argoproj/argo-workflows/blob/master/pkg/apis/workflow/v1alpha1/workflow_phase.go +const ( + nodePending nodePhase = "Pending" + nodeRunning nodePhase = "Running" + nodeSucceeded nodePhase = "Succeeded" + nodeFailed nodePhase = "Failed" + nodeError nodePhase = "Error" +) + +func getArgoWorkflowHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + phase, _, _ := unstructured.NestedString(obj.Object, "status", "phase") + message, _, _ := unstructured.NestedString(obj.Object, "status", "message") + + switch nodePhase(phase) { + case "", nodePending, nodeRunning: + return &HealthStatus{Status: HealthStatusProgressing, Message: message}, nil + case nodeSucceeded: + return &HealthStatus{Status: HealthStatusHealthy, Message: message}, nil + case nodeFailed, nodeError: + return &HealthStatus{Status: HealthStatusDegraded, Message: message}, nil + } + return &HealthStatus{Status: HealthStatusUnknown, Message: message}, nil +} diff --git a/gitops-engine/pkg/health/health_daemonset.go b/gitops-engine/pkg/health/health_daemonset.go new file mode 100644 index 0000000000000..9cb9eff8e65c4 --- /dev/null +++ b/gitops-engine/pkg/health/health_daemonset.go @@ -0,0 +1,57 @@ +package health + +import ( + "fmt" + + appsv1 "k8s.io/api/apps/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getDaemonSetHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case appsv1.SchemeGroupVersion.WithKind(kube.DaemonSetKind): + var daemon appsv1.DaemonSet + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &daemon) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured DaemonSet to typed: %w", err) + } + return getAppsv1DaemonSetHealth(&daemon) + default: + return nil, fmt.Errorf("unsupported DaemonSet GVK: %s", gvk) + } +} + +func getAppsv1DaemonSetHealth(daemon *appsv1.DaemonSet) (*HealthStatus, error) { + // Borrowed at kubernetes/kubectl/rollout_status.go https://github.com/kubernetes/kubernetes/blob/5232ad4a00ec93942d0b2c6359ee6cd1201b46bc/pkg/kubectl/rollout_status.go#L110 + if daemon.Generation > daemon.Status.ObservedGeneration { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting for rollout to finish: observed daemon set generation less than desired generation", + }, nil + } + if daemon.Spec.UpdateStrategy.Type == appsv1.OnDeleteDaemonSetStrategyType { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("daemon set %d out of %d new pods have been updated", daemon.Status.UpdatedNumberScheduled, daemon.Status.DesiredNumberScheduled), + }, nil + } + if daemon.Status.UpdatedNumberScheduled < daemon.Status.DesiredNumberScheduled { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for daemon set %q rollout to finish: %d out of %d new pods have been updated...", daemon.Name, daemon.Status.UpdatedNumberScheduled, daemon.Status.DesiredNumberScheduled), + }, nil + } + if daemon.Status.NumberAvailable < daemon.Status.DesiredNumberScheduled { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for daemon set %q rollout to finish: %d of %d updated pods are available...", daemon.Name, daemon.Status.NumberAvailable, daemon.Status.DesiredNumberScheduled), + }, nil + } + return &HealthStatus{ + Status: HealthStatusHealthy, + }, nil +} diff --git a/gitops-engine/pkg/health/health_deployment.go b/gitops-engine/pkg/health/health_deployment.go new file mode 100644 index 0000000000000..4f7984a2f4861 --- /dev/null +++ b/gitops-engine/pkg/health/health_deployment.go @@ -0,0 +1,80 @@ +package health + +import ( + "fmt" + + appsv1 "k8s.io/api/apps/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getDeploymentHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case appsv1.SchemeGroupVersion.WithKind(kube.DeploymentKind): + var deployment appsv1.Deployment + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &deployment) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured Deployment to typed: %w", err) + } + return getAppsv1DeploymentHealth(&deployment) + default: + return nil, fmt.Errorf("unsupported Deployment GVK: %s", gvk) + } +} + +func getAppsv1DeploymentHealth(deployment *appsv1.Deployment) (*HealthStatus, error) { + if deployment.Spec.Paused { + return &HealthStatus{ + Status: HealthStatusSuspended, + Message: "Deployment is paused", + }, nil + } + // Borrowed at kubernetes/kubectl/rollout_status.go https://github.com/kubernetes/kubernetes/blob/5232ad4a00ec93942d0b2c6359ee6cd1201b46bc/pkg/kubectl/rollout_status.go#L80 + if deployment.Generation <= deployment.Status.ObservedGeneration { + cond := getAppsv1DeploymentCondition(deployment.Status, appsv1.DeploymentProgressing) + switch { + case cond != nil && cond.Reason == "ProgressDeadlineExceeded": + return &HealthStatus{ + Status: HealthStatusDegraded, + Message: fmt.Sprintf("Deployment %q exceeded its progress deadline", deployment.Name), + }, nil + case deployment.Spec.Replicas != nil && deployment.Status.UpdatedReplicas < *deployment.Spec.Replicas: + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for rollout to finish: %d out of %d new replicas have been updated...", deployment.Status.UpdatedReplicas, *deployment.Spec.Replicas), + }, nil + case deployment.Status.Replicas > deployment.Status.UpdatedReplicas: + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for rollout to finish: %d old replicas are pending termination...", deployment.Status.Replicas-deployment.Status.UpdatedReplicas), + }, nil + case deployment.Status.AvailableReplicas < deployment.Status.UpdatedReplicas: + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for rollout to finish: %d of %d updated replicas are available...", deployment.Status.AvailableReplicas, deployment.Status.UpdatedReplicas), + }, nil + } + } else { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting for rollout to finish: observed deployment generation less than desired generation", + }, nil + } + + return &HealthStatus{ + Status: HealthStatusHealthy, + }, nil +} + +func getAppsv1DeploymentCondition(status appsv1.DeploymentStatus, condType appsv1.DeploymentConditionType) *appsv1.DeploymentCondition { + for i := range status.Conditions { + c := status.Conditions[i] + if c.Type == condType { + return &c + } + } + return nil +} diff --git a/gitops-engine/pkg/health/health_hpa.go b/gitops-engine/pkg/health/health_hpa.go new file mode 100644 index 0000000000000..67d178767403f --- /dev/null +++ b/gitops-engine/pkg/health/health_hpa.go @@ -0,0 +1,175 @@ +package health + +import ( + "encoding/json" + "fmt" + + autoscalingv1 "k8s.io/api/autoscaling/v1" + autoscalingv2 "k8s.io/api/autoscaling/v2" + autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1" + autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +var progressingStatus = &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting to Autoscale", +} + +type hpaCondition struct { + Type string + Reason string + Message string + Status string +} + +func getHPAHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + failedConversionMsg := "failed to convert unstructured HPA to typed: %v" + + switch gvk { + case autoscalingv1.SchemeGroupVersion.WithKind(kube.HorizontalPodAutoscalerKind): + var hpa autoscalingv1.HorizontalPodAutoscaler + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &hpa) + if err != nil { + return nil, fmt.Errorf(failedConversionMsg, err) + } + return getAutoScalingV1HPAHealth(&hpa) + case autoscalingv2beta1.SchemeGroupVersion.WithKind(kube.HorizontalPodAutoscalerKind): + var hpa autoscalingv2beta1.HorizontalPodAutoscaler + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &hpa) + if err != nil { + return nil, fmt.Errorf(failedConversionMsg, err) + } + return getAutoScalingV2beta1HPAHealth(&hpa) + case autoscalingv2beta2.SchemeGroupVersion.WithKind(kube.HorizontalPodAutoscalerKind): + var hpa autoscalingv2beta2.HorizontalPodAutoscaler + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &hpa) + if err != nil { + return nil, fmt.Errorf(failedConversionMsg, err) + } + return getAutoScalingV2beta2HPAHealth(&hpa) + case autoscalingv2.SchemeGroupVersion.WithKind(kube.HorizontalPodAutoscalerKind): + var hpa autoscalingv2.HorizontalPodAutoscaler + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &hpa) + if err != nil { + return nil, fmt.Errorf(failedConversionMsg, err) + } + return getAutoScalingV2HPAHealth(&hpa) + default: + return nil, fmt.Errorf("unsupported HPA GVK: %s", gvk) + } +} + +func getAutoScalingV2HPAHealth(hpa *autoscalingv2.HorizontalPodAutoscaler) (*HealthStatus, error) { + statusConditions := hpa.Status.Conditions + conditions := make([]hpaCondition, 0, len(statusConditions)) + for _, statusCondition := range statusConditions { + conditions = append(conditions, hpaCondition{ + Type: string(statusCondition.Type), + Reason: statusCondition.Reason, + Message: statusCondition.Message, + Status: string(statusCondition.Status), + }) + } + + return checkConditions(conditions, progressingStatus) +} + +func getAutoScalingV2beta2HPAHealth(hpa *autoscalingv2beta2.HorizontalPodAutoscaler) (*HealthStatus, error) { + statusConditions := hpa.Status.Conditions + conditions := make([]hpaCondition, 0, len(statusConditions)) + for _, statusCondition := range statusConditions { + conditions = append(conditions, hpaCondition{ + Type: string(statusCondition.Type), + Reason: statusCondition.Reason, + Message: statusCondition.Message, + Status: string(statusCondition.Status), + }) + } + + return checkConditions(conditions, progressingStatus) +} + +func getAutoScalingV2beta1HPAHealth(hpa *autoscalingv2beta1.HorizontalPodAutoscaler) (*HealthStatus, error) { + statusConditions := hpa.Status.Conditions + conditions := make([]hpaCondition, 0, len(statusConditions)) + for _, statusCondition := range statusConditions { + conditions = append(conditions, hpaCondition{ + Type: string(statusCondition.Type), + Reason: statusCondition.Reason, + Message: statusCondition.Message, + Status: string(statusCondition.Status), + }) + } + + return checkConditions(conditions, progressingStatus) +} + +func getAutoScalingV1HPAHealth(hpa *autoscalingv1.HorizontalPodAutoscaler) (*HealthStatus, error) { + annotation, ok := hpa.GetAnnotations()["autoscaling.alpha.kubernetes.io/conditions"] + if !ok { + return progressingStatus, nil + } + + var conditions []hpaCondition + err := json.Unmarshal([]byte(annotation), &conditions) + if err != nil { + failedMessage := "failed to convert conditions annotation to typed: %v" + return nil, fmt.Errorf(failedMessage, err) + } + + if len(conditions) == 0 { + return progressingStatus, nil + } + + return checkConditions(conditions, progressingStatus) +} + +func checkConditions(conditions []hpaCondition, progressingStatus *HealthStatus) (*HealthStatus, error) { + for _, condition := range conditions { + if isDegraded(&condition) { + return &HealthStatus{ + Status: HealthStatusDegraded, + Message: condition.Message, + }, nil + } + + if isHealthy(&condition) { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: condition.Message, + }, nil + } + } + + return progressingStatus, nil +} + +func isDegraded(condition *hpaCondition) bool { + degraded_states := []hpaCondition{ + {Type: "AbleToScale", Reason: "FailedGetScale"}, + {Type: "AbleToScale", Reason: "FailedUpdateScale"}, + {Type: "ScalingActive", Reason: "FailedGetResourceMetric"}, + {Type: "ScalingActive", Reason: "InvalidSelector"}, + } + for _, degraded_state := range degraded_states { + if condition.Type == degraded_state.Type && condition.Reason == degraded_state.Reason { + return true + } + } + return false +} + +func isHealthy(condition *hpaCondition) bool { + healthyConditionTypes := []string{"AbleToScale", "ScalingLimited"} + for _, conditionType := range healthyConditionTypes { + if condition.Type == conditionType && condition.Status == "True" { + return true + } + } + return false +} diff --git a/gitops-engine/pkg/health/health_ingress.go b/gitops-engine/pkg/health/health_ingress.go new file mode 100644 index 0000000000000..87de2d3e976ee --- /dev/null +++ b/gitops-engine/pkg/health/health_ingress.go @@ -0,0 +1,16 @@ +package health + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +func getIngressHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + ingresses, _, _ := unstructured.NestedSlice(obj.Object, "status", "loadBalancer", "ingress") + health := HealthStatus{} + if len(ingresses) > 0 { + health.Status = HealthStatusHealthy + } else { + health.Status = HealthStatusProgressing + } + return &health, nil +} diff --git a/gitops-engine/pkg/health/health_job.go b/gitops-engine/pkg/health/health_job.go new file mode 100644 index 0000000000000..b79b4d9022c1d --- /dev/null +++ b/gitops-engine/pkg/health/health_job.go @@ -0,0 +1,75 @@ +package health + +import ( + "fmt" + + corev1 "k8s.io/api/core/v1" + + batchv1 "k8s.io/api/batch/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getJobHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case batchv1.SchemeGroupVersion.WithKind(kube.JobKind): + var job batchv1.Job + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &job) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured Job to typed: %w", err) + } + return getBatchv1JobHealth(&job) + default: + return nil, fmt.Errorf("unsupported Job GVK: %s", gvk) + } +} + +func getBatchv1JobHealth(job *batchv1.Job) (*HealthStatus, error) { + failed := false + var failMsg string + complete := false + var message string + isSuspended := false + for _, condition := range job.Status.Conditions { + switch condition.Type { + case batchv1.JobFailed: + failed = true + complete = true + failMsg = condition.Message + case batchv1.JobComplete: + complete = true + message = condition.Message + case batchv1.JobSuspended: + complete = true + message = condition.Message + if condition.Status == corev1.ConditionTrue { + isSuspended = true + } + } + } + switch { + case !complete: + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: message, + }, nil + case failed: + return &HealthStatus{ + Status: HealthStatusDegraded, + Message: failMsg, + }, nil + case isSuspended: + return &HealthStatus{ + Status: HealthStatusSuspended, + Message: failMsg, + }, nil + default: + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: message, + }, nil + } +} diff --git a/gitops-engine/pkg/health/health_pod.go b/gitops-engine/pkg/health/health_pod.go new file mode 100644 index 0000000000000..9ebcef5581e1b --- /dev/null +++ b/gitops-engine/pkg/health/health_pod.go @@ -0,0 +1,134 @@ +package health + +import ( + "fmt" + "strings" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/kubectl/pkg/util/podutils" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getPodHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case corev1.SchemeGroupVersion.WithKind(kube.PodKind): + var pod corev1.Pod + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &pod) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured Pod to typed: %w", err) + } + return getCorev1PodHealth(&pod) + default: + return nil, fmt.Errorf("unsupported Pod GVK: %s", gvk) + } +} + +func getCorev1PodHealth(pod *corev1.Pod) (*HealthStatus, error) { + // This logic cannot be applied when the pod.Spec.RestartPolicy is: corev1.RestartPolicyOnFailure, + // corev1.RestartPolicyNever, otherwise it breaks the resource hook logic. + // The issue is, if we mark a pod with ImagePullBackOff as Degraded, and the pod is used as a resource hook, + // then we will prematurely fail the PreSync/PostSync hook. Meanwhile, when that error condition is resolved + // (e.g. the image is available), the resource hook pod will unexpectedly be executed even though the sync has + // completed. + if pod.Spec.RestartPolicy == corev1.RestartPolicyAlways { + var status HealthStatusCode + var messages []string + + for _, containerStatus := range pod.Status.ContainerStatuses { + waiting := containerStatus.State.Waiting + // Article listing common container errors: https://medium.com/kokster/debugging-crashloopbackoffs-with-init-containers-26f79e9fb5bf + if waiting != nil && (strings.HasPrefix(waiting.Reason, "Err") || strings.HasSuffix(waiting.Reason, "Error") || strings.HasSuffix(waiting.Reason, "BackOff")) { + status = HealthStatusDegraded + messages = append(messages, waiting.Message) + } + } + + if status != "" { + return &HealthStatus{ + Status: status, + Message: strings.Join(messages, ", "), + }, nil + } + } + + getFailMessage := func(ctr *corev1.ContainerStatus) string { + if ctr.State.Terminated != nil { + if ctr.State.Terminated.Message != "" { + return ctr.State.Terminated.Message + } + if ctr.State.Terminated.Reason == "OOMKilled" { + return ctr.State.Terminated.Reason + } + if ctr.State.Terminated.ExitCode != 0 { + return fmt.Sprintf("container %q failed with exit code %d", ctr.Name, ctr.State.Terminated.ExitCode) + } + } + return "" + } + + switch pod.Status.Phase { + case corev1.PodPending: + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: pod.Status.Message, + }, nil + case corev1.PodSucceeded: + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: pod.Status.Message, + }, nil + case corev1.PodFailed: + if pod.Status.Message != "" { + // Pod has a nice error message. Use that. + return &HealthStatus{Status: HealthStatusDegraded, Message: pod.Status.Message}, nil + } + for _, ctr := range append(pod.Status.InitContainerStatuses, pod.Status.ContainerStatuses...) { + if msg := getFailMessage(&ctr); msg != "" { + return &HealthStatus{Status: HealthStatusDegraded, Message: msg}, nil + } + } + + return &HealthStatus{Status: HealthStatusDegraded, Message: ""}, nil + case corev1.PodRunning: + switch pod.Spec.RestartPolicy { + case corev1.RestartPolicyAlways: + // if pod is ready, it is automatically healthy + if podutils.IsPodReady(pod) { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: pod.Status.Message, + }, nil + } + // if it's not ready, check to see if any container terminated, if so, it's degraded + for _, ctrStatus := range pod.Status.ContainerStatuses { + if ctrStatus.LastTerminationState.Terminated != nil { + return &HealthStatus{ + Status: HealthStatusDegraded, + Message: pod.Status.Message, + }, nil + } + } + // otherwise we are progressing towards a ready state + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: pod.Status.Message, + }, nil + case corev1.RestartPolicyOnFailure, corev1.RestartPolicyNever: + // pods set with a restart policy of OnFailure or Never, have a finite life. + // These pods are typically resource hooks. Thus, we consider these as Progressing + // instead of healthy. + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: pod.Status.Message, + }, nil + } + } + return &HealthStatus{ + Status: HealthStatusUnknown, + Message: pod.Status.Message, + }, nil +} diff --git a/gitops-engine/pkg/health/health_pvc.go b/gitops-engine/pkg/health/health_pvc.go new file mode 100644 index 0000000000000..7d41120a0d5f0 --- /dev/null +++ b/gitops-engine/pkg/health/health_pvc.go @@ -0,0 +1,41 @@ +package health + +import ( + "fmt" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getPVCHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case corev1.SchemeGroupVersion.WithKind(kube.PersistentVolumeClaimKind): + var pvc corev1.PersistentVolumeClaim + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &pvc) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured PersistentVolumeClaim to typed: %w", err) + } + return getCorev1PVCHealth(&pvc) + default: + return nil, fmt.Errorf("unsupported PersistentVolumeClaim GVK: %s", gvk) + } +} + +func getCorev1PVCHealth(pvc *corev1.PersistentVolumeClaim) (*HealthStatus, error) { + var status HealthStatusCode + switch pvc.Status.Phase { + case corev1.ClaimLost: + status = HealthStatusDegraded + case corev1.ClaimPending: + status = HealthStatusProgressing + case corev1.ClaimBound: + status = HealthStatusHealthy + default: + status = HealthStatusUnknown + } + return &HealthStatus{Status: status}, nil +} diff --git a/gitops-engine/pkg/health/health_replicaset.go b/gitops-engine/pkg/health/health_replicaset.go new file mode 100644 index 0000000000000..7d59eaccc0508 --- /dev/null +++ b/gitops-engine/pkg/health/health_replicaset.go @@ -0,0 +1,63 @@ +package health + +import ( + "fmt" + + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getReplicaSetHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case appsv1.SchemeGroupVersion.WithKind(kube.ReplicaSetKind): + var replicaSet appsv1.ReplicaSet + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &replicaSet) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured ReplicaSet to typed: %w", err) + } + return getAppsv1ReplicaSetHealth(&replicaSet) + default: + return nil, fmt.Errorf("unsupported ReplicaSet GVK: %s", gvk) + } +} + +func getAppsv1ReplicaSetHealth(replicaSet *appsv1.ReplicaSet) (*HealthStatus, error) { + if replicaSet.Generation <= replicaSet.Status.ObservedGeneration { + cond := getAppsv1ReplicaSetCondition(replicaSet.Status, appsv1.ReplicaSetReplicaFailure) + if cond != nil && cond.Status == corev1.ConditionTrue { + return &HealthStatus{ + Status: HealthStatusDegraded, + Message: cond.Message, + }, nil + } else if replicaSet.Spec.Replicas != nil && replicaSet.Status.AvailableReplicas < *replicaSet.Spec.Replicas { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for rollout to finish: %d out of %d new replicas are available...", replicaSet.Status.AvailableReplicas, *replicaSet.Spec.Replicas), + }, nil + } + } else { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting for rollout to finish: observed replica set generation less than desired generation", + }, nil + } + + return &HealthStatus{ + Status: HealthStatusHealthy, + }, nil +} + +func getAppsv1ReplicaSetCondition(status appsv1.ReplicaSetStatus, condType appsv1.ReplicaSetConditionType) *appsv1.ReplicaSetCondition { + for i := range status.Conditions { + c := status.Conditions[i] + if c.Type == condType { + return &c + } + } + return nil +} diff --git a/gitops-engine/pkg/health/health_service.go b/gitops-engine/pkg/health/health_service.go new file mode 100644 index 0000000000000..ea8cda2bb8445 --- /dev/null +++ b/gitops-engine/pkg/health/health_service.go @@ -0,0 +1,38 @@ +package health + +import ( + "fmt" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getServiceHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case corev1.SchemeGroupVersion.WithKind(kube.ServiceKind): + var service corev1.Service + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &service) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured Service to typed: %w", err) + } + return getCorev1ServiceHealth(&service) + default: + return nil, fmt.Errorf("unsupported Service GVK: %s", gvk) + } +} + +func getCorev1ServiceHealth(service *corev1.Service) (*HealthStatus, error) { + health := HealthStatus{Status: HealthStatusHealthy} + if service.Spec.Type == corev1.ServiceTypeLoadBalancer { + if len(service.Status.LoadBalancer.Ingress) > 0 { + health.Status = HealthStatusHealthy + } else { + health.Status = HealthStatusProgressing + } + } + return &health, nil +} diff --git a/gitops-engine/pkg/health/health_statefulset.go b/gitops-engine/pkg/health/health_statefulset.go new file mode 100644 index 0000000000000..920e5ed2d14a7 --- /dev/null +++ b/gitops-engine/pkg/health/health_statefulset.go @@ -0,0 +1,73 @@ +package health + +import ( + "fmt" + + appsv1 "k8s.io/api/apps/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +func getStatefulSetHealth(obj *unstructured.Unstructured) (*HealthStatus, error) { + gvk := obj.GroupVersionKind() + switch gvk { + case appsv1.SchemeGroupVersion.WithKind(kube.StatefulSetKind): + var sts appsv1.StatefulSet + err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, &sts) + if err != nil { + return nil, fmt.Errorf("failed to convert unstructured StatefulSet to typed: %w", err) + } + return getAppsv1StatefulSetHealth(&sts) + default: + return nil, fmt.Errorf("unsupported StatefulSet GVK: %s", gvk) + } +} + +func getAppsv1StatefulSetHealth(sts *appsv1.StatefulSet) (*HealthStatus, error) { + // Borrowed at kubernetes/kubectl/rollout_status.go https://github.com/kubernetes/kubernetes/blob/5232ad4a00ec93942d0b2c6359ee6cd1201b46bc/pkg/kubectl/rollout_status.go#L131 + if sts.Status.ObservedGeneration == 0 || sts.Generation > sts.Status.ObservedGeneration { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: "Waiting for statefulset spec update to be observed...", + }, nil + } + if sts.Spec.Replicas != nil && sts.Status.ReadyReplicas < *sts.Spec.Replicas { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for %d pods to be ready...", *sts.Spec.Replicas-sts.Status.ReadyReplicas), + }, nil + } + if sts.Spec.UpdateStrategy.Type == appsv1.RollingUpdateStatefulSetStrategyType && sts.Spec.UpdateStrategy.RollingUpdate != nil { + if sts.Spec.Replicas != nil && sts.Spec.UpdateStrategy.RollingUpdate.Partition != nil { + if sts.Status.UpdatedReplicas < (*sts.Spec.Replicas - *sts.Spec.UpdateStrategy.RollingUpdate.Partition) { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("Waiting for partitioned roll out to finish: %d out of %d new pods have been updated...", + sts.Status.UpdatedReplicas, (*sts.Spec.Replicas - *sts.Spec.UpdateStrategy.RollingUpdate.Partition)), + }, nil + } + } + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("partitioned roll out complete: %d new pods have been updated...", sts.Status.UpdatedReplicas), + }, nil + } + if sts.Spec.UpdateStrategy.Type == appsv1.OnDeleteStatefulSetStrategyType { + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("statefulset has %d ready pods", sts.Status.ReadyReplicas), + }, nil + } + if sts.Status.UpdateRevision != sts.Status.CurrentRevision { + return &HealthStatus{ + Status: HealthStatusProgressing, + Message: fmt.Sprintf("waiting for statefulset rolling update to complete %d pods at revision %s...", sts.Status.UpdatedReplicas, sts.Status.UpdateRevision), + }, nil + } + return &HealthStatus{ + Status: HealthStatusHealthy, + Message: fmt.Sprintf("statefulset rolling update complete %d pods at revision %s...", sts.Status.CurrentReplicas, sts.Status.CurrentRevision), + }, nil +} diff --git a/gitops-engine/pkg/health/health_test.go b/gitops-engine/pkg/health/health_test.go new file mode 100644 index 0000000000000..0adf683cc4c9b --- /dev/null +++ b/gitops-engine/pkg/health/health_test.go @@ -0,0 +1,174 @@ +/* +Package provides functionality that allows assessing the health state of a Kubernetes resource. +*/ + +package health + +import ( + "os" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "sigs.k8s.io/yaml" +) + +func assertAppHealth(t *testing.T, yamlPath string, expectedStatus HealthStatusCode) { + t.Helper() + health := getHealthStatus(t, yamlPath) + assert.NotNil(t, health) + assert.Equal(t, expectedStatus, health.Status) +} + +func getHealthStatus(t *testing.T, yamlPath string) *HealthStatus { + t.Helper() + yamlBytes, err := os.ReadFile(yamlPath) + require.NoError(t, err) + var obj unstructured.Unstructured + err = yaml.Unmarshal(yamlBytes, &obj) + require.NoError(t, err) + health, err := GetResourceHealth(&obj, nil) + require.NoError(t, err) + return health +} + +func TestDeploymentHealth(t *testing.T) { + assertAppHealth(t, "../utils/kube/testdata/nginx.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/deployment-progressing.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/deployment-suspended.yaml", HealthStatusSuspended) + assertAppHealth(t, "./testdata/deployment-degraded.yaml", HealthStatusDegraded) +} + +func TestStatefulSetHealth(t *testing.T) { + assertAppHealth(t, "./testdata/statefulset.yaml", HealthStatusHealthy) +} + +func TestStatefulSetOnDeleteHealth(t *testing.T) { + assertAppHealth(t, "./testdata/statefulset-ondelete.yaml", HealthStatusHealthy) +} + +func TestDaemonSetOnDeleteHealth(t *testing.T) { + assertAppHealth(t, "./testdata/daemonset-ondelete.yaml", HealthStatusHealthy) +} + +func TestPVCHealth(t *testing.T) { + assertAppHealth(t, "./testdata/pvc-bound.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/pvc-pending.yaml", HealthStatusProgressing) +} + +func TestServiceHealth(t *testing.T) { + assertAppHealth(t, "./testdata/svc-clusterip.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/svc-loadbalancer.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/svc-loadbalancer-unassigned.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/svc-loadbalancer-nonemptylist.yaml", HealthStatusHealthy) +} + +func TestIngressHealth(t *testing.T) { + assertAppHealth(t, "./testdata/ingress.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/ingress-unassigned.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/ingress-nonemptylist.yaml", HealthStatusHealthy) +} + +func TestCRD(t *testing.T) { + assert.Nil(t, getHealthStatus(t, "./testdata/knative-service.yaml")) +} + +func TestJob(t *testing.T) { + assertAppHealth(t, "./testdata/job-running.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/job-failed.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/job-succeeded.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/job-suspended.yaml", HealthStatusSuspended) +} + +func TestHPA(t *testing.T) { + assertAppHealth(t, "./testdata/hpa-v2-healthy.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v2-degraded.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/hpa-v2-progressing.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/hpa-v2beta2-healthy.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v2beta1-healthy-disabled.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v2beta1-healthy.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v1-degraded.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/hpa-v1-healthy.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v1-healthy-toofew.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/hpa-v1-progressing.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/hpa-v1-progressing-with-no-annotations.yaml", HealthStatusProgressing) +} + +func TestPod(t *testing.T) { + assertAppHealth(t, "./testdata/pod-pending.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/pod-running-not-ready.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/pod-crashloop.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/pod-imagepullbackoff.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/pod-error.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/pod-running-restart-always.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/pod-running-restart-never.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/pod-running-restart-onfailure.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/pod-failed.yaml", HealthStatusDegraded) + assertAppHealth(t, "./testdata/pod-succeeded.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/pod-deletion.yaml", HealthStatusProgressing) +} + +func TestApplication(t *testing.T) { + assert.Nil(t, getHealthStatus(t, "./testdata/application-healthy.yaml")) + assert.Nil(t, getHealthStatus(t, "./testdata/application-degraded.yaml")) +} + +func TestAPIService(t *testing.T) { + assertAppHealth(t, "./testdata/apiservice-v1-true.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/apiservice-v1-false.yaml", HealthStatusProgressing) + assertAppHealth(t, "./testdata/apiservice-v1beta1-true.yaml", HealthStatusHealthy) + assertAppHealth(t, "./testdata/apiservice-v1beta1-false.yaml", HealthStatusProgressing) +} + +func TestGetArgoWorkflowHealth(t *testing.T) { + sampleWorkflow := unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "entrypoint": "sampleEntryPoint", + "extraneousKey": "we are agnostic to extraneous keys", + }, + "status": map[string]any{ + "phase": "Running", + "message": "This node is running", + }, + }, + } + + health, err := getArgoWorkflowHealth(&sampleWorkflow) + require.NoError(t, err) + assert.Equal(t, HealthStatusProgressing, health.Status) + assert.Equal(t, "This node is running", health.Message) + + sampleWorkflow = unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "entrypoint": "sampleEntryPoint", + "extraneousKey": "we are agnostic to extraneous keys", + }, + "status": map[string]any{ + "phase": "Succeeded", + "message": "This node is has succeeded", + }, + }, + } + + health, err = getArgoWorkflowHealth(&sampleWorkflow) + require.NoError(t, err) + assert.Equal(t, HealthStatusHealthy, health.Status) + assert.Equal(t, "This node is has succeeded", health.Message) + + sampleWorkflow = unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "entrypoint": "sampleEntryPoint", + "extraneousKey": "we are agnostic to extraneous keys", + }, + }, + } + + health, err = getArgoWorkflowHealth(&sampleWorkflow) + require.NoError(t, err) + assert.Equal(t, HealthStatusProgressing, health.Status) + assert.Empty(t, health.Message) +} diff --git a/gitops-engine/pkg/health/testdata/apiservice-v1-false.yaml b/gitops-engine/pkg/health/testdata/apiservice-v1-false.yaml new file mode 100644 index 0000000000000..a448823b9eb05 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/apiservice-v1-false.yaml @@ -0,0 +1,23 @@ +apiVersion: apiregistration.k8s.io/v1 +kind: APIService +metadata: + name: v1beta1.admission.cert-manager.io + labels: + app: webhook + app.kubernetes.io/instance: external-dns +spec: + group: admission.cert-manager.io + groupPriorityMinimum: 1000 + versionPriority: 15 + service: + name: cert-manager-webhook + namespace: external-dns + version: v1beta1 +status: + conditions: + - lastTransitionTime: "2019-06-26T07:17:09Z" + message: endpoints for service/cert-manager-webhook in "external-dns" have no + addresses + reason: MissingEndpoints + status: "False" + type: Available diff --git a/gitops-engine/pkg/health/testdata/apiservice-v1-true.yaml b/gitops-engine/pkg/health/testdata/apiservice-v1-true.yaml new file mode 100644 index 0000000000000..9bc6e478ccec2 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/apiservice-v1-true.yaml @@ -0,0 +1,22 @@ +apiVersion: apiregistration.k8s.io/v1 +kind: APIService +metadata: + name: v1beta1.admission.cert-manager.io + labels: + app: webhook + app.kubernetes.io/instance: external-dns +spec: + group: admission.cert-manager.io + groupPriorityMinimum: 1000 + versionPriority: 15 + service: + name: cert-manager-webhook + namespace: external-dns + version: v1beta1 +status: + conditions: + - lastTransitionTime: "2019-07-09T14:48:15Z" + message: all checks passed + reason: Passed + status: "True" + type: Available diff --git a/gitops-engine/pkg/health/testdata/apiservice-v1beta1-false.yaml b/gitops-engine/pkg/health/testdata/apiservice-v1beta1-false.yaml new file mode 100644 index 0000000000000..28436bb880d8e --- /dev/null +++ b/gitops-engine/pkg/health/testdata/apiservice-v1beta1-false.yaml @@ -0,0 +1,23 @@ +apiVersion: apiregistration.k8s.io/v1beta1 +kind: APIService +metadata: + name: v1beta1.admission.cert-manager.io + labels: + app: webhook + app.kubernetes.io/instance: external-dns +spec: + group: admission.cert-manager.io + groupPriorityMinimum: 1000 + versionPriority: 15 + service: + name: cert-manager-webhook + namespace: external-dns + version: v1beta1 +status: + conditions: + - lastTransitionTime: "2019-06-26T07:17:09Z" + message: endpoints for service/cert-manager-webhook in "external-dns" have no + addresses + reason: MissingEndpoints + status: "False" + type: Available diff --git a/gitops-engine/pkg/health/testdata/apiservice-v1beta1-true.yaml b/gitops-engine/pkg/health/testdata/apiservice-v1beta1-true.yaml new file mode 100644 index 0000000000000..45e60b350e8b5 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/apiservice-v1beta1-true.yaml @@ -0,0 +1,22 @@ +apiVersion: apiregistration.k8s.io/v1beta1 +kind: APIService +metadata: + name: v1beta1.admission.cert-manager.io + labels: + app: webhook + app.kubernetes.io/instance: external-dns +spec: + group: admission.cert-manager.io + groupPriorityMinimum: 1000 + versionPriority: 15 + service: + name: cert-manager-webhook + namespace: external-dns + version: v1beta1 +status: + conditions: + - lastTransitionTime: "2019-07-09T14:48:15Z" + message: all checks passed + reason: Passed + status: "True" + type: Available diff --git a/gitops-engine/pkg/health/testdata/application-degraded.yaml b/gitops-engine/pkg/health/testdata/application-degraded.yaml new file mode 100644 index 0000000000000..8e264da0dd4d6 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/application-degraded.yaml @@ -0,0 +1,5 @@ +apiVersion: argoproj.io/v1alpha1 +kind: Application +status: + health: + status: Degraded diff --git a/gitops-engine/pkg/health/testdata/application-healthy.yaml b/gitops-engine/pkg/health/testdata/application-healthy.yaml new file mode 100644 index 0000000000000..8b47209eb9628 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/application-healthy.yaml @@ -0,0 +1,5 @@ +apiVersion: argoproj.io/v1alpha1 +kind: Application +status: + health: + status: Healthy diff --git a/gitops-engine/pkg/health/testdata/daemonset-ondelete.yaml b/gitops-engine/pkg/health/testdata/daemonset-ondelete.yaml new file mode 100644 index 0000000000000..40b30c4a8a6b1 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/daemonset-ondelete.yaml @@ -0,0 +1,53 @@ +apiVersion: apps/v1 +kind: DaemonSet +metadata: + name: fluentd-elasticsearch + namespace: kube-system + labels: + k8s-app: fluentd-logging +spec: + selector: + matchLabels: + name: fluentd-elasticsearch + updateStrategy: + type: OnDelete + template: + metadata: + labels: + name: fluentd-elasticsearch + spec: + tolerations: + # this toleration is to have the daemonset runnable on master nodes + # remove it if your masters can't run pods + - key: node-role.kubernetes.io/master + effect: NoSchedule + containers: + - name: fluentd-elasticsearch + image: quay.io/fluentd_elasticsearch/fluentd:v2.5.1 + resources: + limits: + memory: 200Mi + requests: + cpu: 100m + memory: 200Mi + volumeMounts: + - name: varlog + mountPath: /var/log + - name: varlibdockercontainers + mountPath: /var/lib/docker/containers + readOnly: true + terminationGracePeriodSeconds: 30 + volumes: + - name: varlog + hostPath: + path: /var/log + - name: varlibdockercontainers + hostPath: + path: /var/lib/docker/containers +status: + currentNumberScheduled: 1 + desiredNumberScheduled: 1 + numberAvailable: 1 + numberMisscheduled: 0 + numberReady: 1 + observedGeneration: 4 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/deployment-degraded.yaml b/gitops-engine/pkg/health/testdata/deployment-degraded.yaml new file mode 100644 index 0000000000000..10757674963a5 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/deployment-degraded.yaml @@ -0,0 +1,70 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: "4" + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"labels":{"app.kubernetes.io/instance":"guestbook-default"},"name":"guestbook-ui","namespace":"default"},"spec":{"replicas":1,"selector":{"matchLabels":{"app":"guestbook-ui"}},"template":{"metadata":{"labels":{"app":"guestbook-ui","app.kubernetes.io/instance":"guestbook-default"}},"spec":{"containers":[{"image":"gcr.io/heptio-images/ks-guestbook-demo:0.3","name":"guestbook-ui","ports":[{"containerPort":80}]}]}}}} + creationTimestamp: 2018-07-18T04:40:44Z + generation: 4 + labels: + app.kubernetes.io/instance: guestbook-default + name: guestbook-ui + namespace: default + resourceVersion: "13660" + selfLink: /apis/apps/v1/namespaces/default/deployments/guestbook-ui + uid: bb9af0c7-8a44-11e8-9e23-42010aa80010 +spec: + progressDeadlineSeconds: 600 + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: guestbook-ui + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: guestbook-ui + app.kubernetes.io/instance: guestbook-default + spec: + containers: + - image: gcr.io/heptio-images/ks-guestbook-demo:0.3 + imagePullPolicy: IfNotPresent + name: guestbook-ui + ports: + - containerPort: 80 + protocol: TCP + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 1 + conditions: + - lastTransitionTime: 2018-07-18T04:48:48Z + lastUpdateTime: 2018-07-18T04:48:48Z + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: "True" + type: Available + - lastTransitionTime: 2018-07-18T06:29:23Z + lastUpdateTime: 2018-07-18T06:29:23Z + message: ReplicaSet "guestbook-ui-75dd4d49d5" has timed out progressing. + reason: ProgressDeadlineExceeded + status: "False" + type: Progressing + observedGeneration: 4 + readyReplicas: 1 + replicas: 2 + unavailableReplicas: 1 + updatedReplicas: 1 diff --git a/gitops-engine/pkg/health/testdata/deployment-progressing.yaml b/gitops-engine/pkg/health/testdata/deployment-progressing.yaml new file mode 100644 index 0000000000000..8a059256b0a4b --- /dev/null +++ b/gitops-engine/pkg/health/testdata/deployment-progressing.yaml @@ -0,0 +1,70 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: "4" + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"labels":{"app.kubernetes.io/instance":"guestbook-default"},"name":"guestbook-ui","namespace":"default"},"spec":{"replicas":1,"selector":{"matchLabels":{"app":"guestbook-ui"}},"template":{"metadata":{"labels":{"app":"guestbook-ui","app.kubernetes.io/instance":"guestbook-default"}},"spec":{"containers":[{"image":"gcr.io/heptio-images/ks-guestbook-demo:0.3","name":"guestbook-ui","ports":[{"containerPort":80}]}]}}}} + creationTimestamp: 2018-07-18T04:40:44Z + generation: 4 + labels: + app.kubernetes.io/instance: guestbook-default + name: guestbook-ui + namespace: default + resourceVersion: "12819" + selfLink: /apis/apps/v1/namespaces/default/deployments/guestbook-ui + uid: bb9af0c7-8a44-11e8-9e23-42010aa80010 +spec: + progressDeadlineSeconds: 600 + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: guestbook-ui + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: guestbook-ui + app.kubernetes.io/instance: guestbook-default + spec: + containers: + - image: gcr.io/heptio-images/ks-guestbook-demo:0.3 + imagePullPolicy: IfNotPresent + name: guestbook-ui + ports: + - containerPort: 80 + protocol: TCP + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 1 + conditions: + - lastTransitionTime: 2018-07-18T04:48:48Z + lastUpdateTime: 2018-07-18T04:48:48Z + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: "True" + type: Available + - lastTransitionTime: 2018-07-18T04:40:44Z + lastUpdateTime: 2018-07-18T06:19:22Z + message: ReplicaSet "guestbook-ui-75dd4d49d5" is progressing. + reason: ReplicaSetUpdated + status: "True" + type: Progressing + observedGeneration: 4 + readyReplicas: 1 + replicas: 2 + unavailableReplicas: 1 + updatedReplicas: 1 diff --git a/gitops-engine/pkg/health/testdata/deployment-suspended.yaml b/gitops-engine/pkg/health/testdata/deployment-suspended.yaml new file mode 100644 index 0000000000000..e8c5a40f2b2e9 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/deployment-suspended.yaml @@ -0,0 +1,71 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: "4" + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"labels":{"app.kubernetes.io/instance":"guestbook-default"},"name":"guestbook-ui","namespace":"default"},"spec":{"replicas":1,"selector":{"matchLabels":{"app":"guestbook-ui"}},"template":{"metadata":{"labels":{"app":"guestbook-ui","app.kubernetes.io/instance":"guestbook-default"}},"spec":{"containers":[{"image":"gcr.io/heptio-images/ks-guestbook-demo:0.3","name":"guestbook-ui","ports":[{"containerPort":80}]}]}}}} + creationTimestamp: 2018-07-18T04:40:44Z + generation: 4 + labels: + app.kubernetes.io/instance: guestbook-default + name: guestbook-ui + namespace: default + resourceVersion: "12819" + selfLink: /apis/apps/v1/namespaces/default/deployments/guestbook-ui + uid: bb9af0c7-8a44-11e8-9e23-42010aa80010 +spec: + progressDeadlineSeconds: 600 + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: guestbook-ui + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + paused: true + template: + metadata: + creationTimestamp: null + labels: + app: guestbook-ui + app.kubernetes.io/instance: guestbook-default + spec: + containers: + - image: gcr.io/heptio-images/ks-guestbook-demo:0.3 + imagePullPolicy: IfNotPresent + name: guestbook-ui + ports: + - containerPort: 80 + protocol: TCP + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 1 + conditions: + - lastTransitionTime: 2018-07-18T04:48:48Z + lastUpdateTime: 2018-07-18T04:48:48Z + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: "True" + type: Available + - lastTransitionTime: 2018-07-18T04:40:44Z + lastUpdateTime: 2018-07-18T06:19:22Z + message: ReplicaSet "guestbook-ui-75dd4d49d5" is progressing. + reason: ReplicaSetUpdated + status: "True" + type: Progressing + observedGeneration: 4 + readyReplicas: 1 + replicas: 2 + unavailableReplicas: 1 + updatedReplicas: 1 diff --git a/gitops-engine/pkg/health/testdata/hpa-v1-degraded.yaml b/gitops-engine/pkg/health/testdata/hpa-v1-degraded.yaml new file mode 100644 index 0000000000000..90cd02fdd1c5e --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v1-degraded.yaml @@ -0,0 +1,21 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + annotations: + autoscaling.alpha.kubernetes.io/conditions: '[{"type":"AbleToScale","status":"True","lastTransitionTime":"2020-11-23T19:38:38Z","reason":"FailedGetScale","message":"the HPA controller was unable to get the target''s current scale"},{"type":"ScalingActive","status":"False","lastTransitionTime":"2020-11-23T19:38:38Z","reason":"FailedGetResourceMetric","message":"the + HPA was unable to compute the replica count: unable to get metrics for resource + cpu: unable to fetch metrics from resource metrics API: the server is currently + unable to handle the request (get pods.metrics.k8s.io)"}]' + name: sample + namespace: argocd +spec: + maxReplicas: 1 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: sample + targetCPUUtilizationPercentage: 2 +status: + currentReplicas: 1 + desiredReplicas: 0 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v1-healthy-toofew.yaml b/gitops-engine/pkg/health/testdata/hpa-v1-healthy-toofew.yaml new file mode 100644 index 0000000000000..605a6b450f5d8 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v1-healthy-toofew.yaml @@ -0,0 +1,28 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + annotations: + autoscaling.alpha.kubernetes.io/conditions: '[{"type":"AbleToScale","status":"True","lastTransitionTime":"2021-03-08T17:42:11Z","reason":"ReadyForNewScale","message":"recommended + size matches current size"},{"type":"ScalingActive","status":"True","lastTransitionTime":"2021-03-09T23:59:49Z","reason":"ValidMetricFound","message":"the + HPA was able to successfully calculate a replica count from memory resource + utilization (percentage of request)"},{"type":"ScalingLimited","status":"True","lastTransitionTime":"2021-03-10T10:02:12Z","reason":"TooFewReplicas","message":"the + desired replica count is less than the minimum replica count"}]' + autoscaling.alpha.kubernetes.io/current-metrics: '[{"type":"Resource","resource":{"name":"memory","currentAverageUtilization":2,"currentAverageValue":"3452928"}},{"type":"Resource","resource":{"name":"cpu","currentAverageUtilization":1,"currentAverageValue":"1m"}}]' + name: sample + namespace: default + resourceVersion: "41720063" + selfLink: /apis/autoscaling/v1/namespaces/default/horizontalpodautoscalers/sample + uid: cbe887e2-93d6-40de-8f03-7eb7e2d7f978 +spec: + maxReplicas: 10 + minReplicas: 2 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: sample + targetCPUUtilizationPercentage: 80 +status: + currentCPUUtilizationPercentage: 1 + currentReplicas: 2 + desiredReplicas: 2 + lastScaleTime: "2021-03-08T17:42:11Z" diff --git a/gitops-engine/pkg/health/testdata/hpa-v1-healthy.yaml b/gitops-engine/pkg/health/testdata/hpa-v1-healthy.yaml new file mode 100644 index 0000000000000..08782aa23ea08 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v1-healthy.yaml @@ -0,0 +1,21 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + annotations: + autoscaling.alpha.kubernetes.io/conditions: '[{"type":"AbleToScale","status":"True","lastTransitionTime":"2020-11-23T19:38:38Z","reason":"SucceededRescale","message":"the HPA controller was able to update the target scale to 1"},{"type":"ScalingActive","status":"False","lastTransitionTime":"2020-11-23T19:38:38Z","reason":"FailedGetResourceMetric","message":"the + HPA was unable to compute the replica count: unable to get metrics for resource + cpu: unable to fetch metrics from resource metrics API: the server is currently + unable to handle the request (get pods.metrics.k8s.io)"}]' + name: sample + namespace: argocd +spec: + maxReplicas: 2 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: sample + targetCPUUtilizationPercentage: 2 +status: + currentReplicas: 1 + desiredReplicas: 1 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v1-progressing-with-no-annotations.yaml b/gitops-engine/pkg/health/testdata/hpa-v1-progressing-with-no-annotations.yaml new file mode 100644 index 0000000000000..9a3ba588d0a23 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v1-progressing-with-no-annotations.yaml @@ -0,0 +1,16 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + name: sample + namespace: argocd +spec: + maxReplicas: 2 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: sample + targetCPUUtilizationPercentage: 2 +status: + currentReplicas: 1 + desiredReplicas: 1 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v1-progressing.yaml b/gitops-engine/pkg/health/testdata/hpa-v1-progressing.yaml new file mode 100644 index 0000000000000..bb6c3a8c4e49b --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v1-progressing.yaml @@ -0,0 +1,18 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + annotations: + autoscaling.alpha.kubernetes.io/conditions: '[{"type":"AbleToScale","status":"False","lastTransitionTime":"2020-11-23T19:38:38Z","reason":"SucceededGetScale","message":"the HPA controller was not able to get the target''s current scale"}]' + name: sample + namespace: argocd +spec: + maxReplicas: 1 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: sample + targetCPUUtilizationPercentage: 2 +status: + currentReplicas: 1 + desiredReplicas: 0 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v2-degraded.yaml b/gitops-engine/pkg/health/testdata/hpa-v2-degraded.yaml new file mode 100644 index 0000000000000..6281b37a1c72c --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2-degraded.yaml @@ -0,0 +1,42 @@ +apiVersion: autoscaling/v2 +kind: HorizontalPodAutoscaler +metadata: + creationTimestamp: "2022-01-17T14:22:27Z" + name: sample + uid: 0e6d855e-83ed-4ed5-b80a-461a750f14db +spec: + maxReplicas: 2 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: argocd-server + targetCPUUtilizationPercentage: 80 +status: + conditions: + - lastTransitionTime: "2022-04-14T19:44:23Z" + message: 'the HPA controller was unable to get the target''s current scale: deployments/scale.apps + "sandbox-test-app-8" not found' + reason: FailedGetScale + status: "False" + type: AbleToScale + - lastTransitionTime: "2022-04-14T15:41:57Z" + message: the HPA was able to successfully calculate a replica count from cpu resource + utilization (percentage of request) + reason: ValidMetricFound + status: "True" + type: ScalingActive + - lastTransitionTime: "2022-01-17T14:24:13Z" + message: the desired count is within the acceptable range + reason: DesiredWithinRange + status: "False" + type: ScalingLimited + currentMetrics: + - resource: + current: + averageUtilization: 6 + averageValue: 12m + name: cpu + type: Resource + currentReplicas: 1 + desiredReplicas: 1 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v2-healthy.yaml b/gitops-engine/pkg/health/testdata/hpa-v2-healthy.yaml new file mode 100644 index 0000000000000..7265b90a09f59 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2-healthy.yaml @@ -0,0 +1,42 @@ +apiVersion: autoscaling/v2 +kind: HorizontalPodAutoscaler +metadata: + creationTimestamp: '2022-05-13T12:39:31Z' + name: sample + uid: 0e6d855e-83ed-4ed5-b80a-461a750f14db +spec: + maxReplicas: 2 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: argocd-server + targetCPUUtilizationPercentage: 80 +status: + conditions: + - lastTransitionTime: '2022-05-13T12:40:34Z' + message: recommended size matches current size + reason: ReadyForNewScale + status: 'True' + type: AbleToScale + - lastTransitionTime: '2022-05-13T12:40:33Z' + message: >- + the HPA was able to successfully calculate a replica count from cpu + resource utilization (percentage of request) + reason: ValidMetricFound + status: 'True' + type: ScalingActive + - lastTransitionTime: '2022-05-13T12:40:31Z' + message: the desired count is within the acceptable range + reason: DesiredWithinRange + status: 'False' + type: ScalingLimited + currentMetrics: + - resource: + current: + averageUtilization: 6 + averageValue: 12m + name: cpu + type: Resource + currentReplicas: 1 + desiredReplicas: 1 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v2-progressing.yaml b/gitops-engine/pkg/health/testdata/hpa-v2-progressing.yaml new file mode 100644 index 0000000000000..c9e66b3d42844 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2-progressing.yaml @@ -0,0 +1,37 @@ +apiVersion: autoscaling/v2 +kind: HorizontalPodAutoscaler +metadata: + creationTimestamp: '2022-05-13T12:39:31Z' + name: sample + uid: 0e6d855e-83ed-4ed5-b80a-461a750f14db +spec: + maxReplicas: 2 + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: argocd-server + targetCPUUtilizationPercentage: 80 +status: + conditions: + - lastTransitionTime: '2022-05-13T12:40:33Z' + message: >- + the HPA was able to successfully calculate a replica count from cpu + resource utilization (percentage of request) + reason: ValidMetricFound + status: 'True' + type: ScalingActive + - lastTransitionTime: '2022-05-13T12:40:31Z' + message: the desired count is within the acceptable range + reason: DesiredWithinRange + status: 'False' + type: ScalingLimited + currentMetrics: + - resource: + current: + averageUtilization: 6 + averageValue: 12m + name: cpu + type: Resource + currentReplicas: 1 + desiredReplicas: 1 \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy-disabled.yaml b/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy-disabled.yaml new file mode 100644 index 0000000000000..54d872824f9fd --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy-disabled.yaml @@ -0,0 +1,37 @@ +apiVersion: autoscaling/v2beta1 +kind: HorizontalPodAutoscaler +metadata: + creationTimestamp: '2021-09-15T09:31:50Z' + name: sample + namespace: argocd + resourceVersion: '18886245' + selfLink: >- + /apis/autoscaling/v2beta1/namespaces/argocd/horizontalpodautoscalers/sample + uid: c10a6092-1607-11ec-a314-020fc740624d +spec: + maxReplicas: 3 + metrics: + - resource: + name: cpu + targetAverageUtilization: 80 + type: Resource + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: test +status: + conditions: + - lastTransitionTime: '2021-09-15T09:32:05Z' + message: the HPA controller was able to get the target's current scale + reason: SucceededGetScale + status: 'True' + type: AbleToScale + - lastTransitionTime: '2021-09-15T09:32:05Z' + message: scaling is disabled since the replica count of the target is zero + reason: ScalingDisabled + status: 'False' + type: ScalingActive + currentMetrics: [] + currentReplicas: 0 + desiredReplicas: 0 diff --git a/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy.yaml b/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy.yaml new file mode 100644 index 0000000000000..ccae0e16df7ca --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2beta1-healthy.yaml @@ -0,0 +1,72 @@ +apiVersion: autoscaling/v2beta1 +kind: HorizontalPodAutoscaler +metadata: + annotations: + kubectl.kubernetes.io/last-applied-configuration: > + {"apiVersion":"autoscaling/v2beta1","kind":"HorizontalPodAutoscaler","metadata":{"annotations":{},"labels":{"app.kubernetes.io/component":"repo-server","app.kubernetes.io/instance":"argocd","app.kubernetes.io/managed-by":"Helm","app.kubernetes.io/name":"argocd-repo-server-hpa","app.kubernetes.io/part-of":"argocd","argocd.argoproj.io/instance":"argocd","helm.sh/chart":"argo-cd-2.5.0"},"name":"argocd-repo-server-hpa","namespace":"argocd"},"spec":{"maxReplicas":40,"metrics":[{"resource":{"name":"memory","targetAverageUtilization":150},"type":"Resource"},{"resource":{"name":"cpu","targetAverageUtilization":80},"type":"Resource"}],"minReplicas":1,"scaleTargetRef":{"apiVersion":"apps/v1","kind":"Deployment","name":"argocd-repo-server"}}} + meta.helm.sh/release-name: argocd + meta.helm.sh/release-namespace: argocd + creationTimestamp: '2020-09-01T23:37:42Z' + labels: + app.kubernetes.io/component: repo-server + app.kubernetes.io/instance: argocd + app.kubernetes.io/managed-by: Helm + app.kubernetes.io/name: argocd-repo-server-hpa + app.kubernetes.io/part-of: argocd + argocd.argoproj.io/instance: argocd + helm.sh/chart: argo-cd-2.5.0 + name: argocd-repo-server-hpa + namespace: argocd + resourceVersion: '65843573' + selfLink: >- + /apis/autoscaling/v2beta1/namespaces/argocd/horizontalpodautoscalers/argocd-repo-server-hpa + uid: ca7e0de8-7eb1-404a-b2f9-b9702b88ca8b +spec: + maxReplicas: 40 + metrics: + - resource: + name: memory + targetAverageUtilization: 150 + type: Resource + - resource: + name: cpu + targetAverageUtilization: 80 + type: Resource + minReplicas: 1 + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: argocd-repo-server +status: + conditions: + - lastTransitionTime: '2020-09-16T17:59:42Z' + message: recommended size matches current size + reason: ReadyForNewScale + status: 'True' + type: AbleToScale + - lastTransitionTime: '2020-11-09T21:31:12Z' + message: >- + the HPA was able to successfully calculate a replica count from memory + resource utilization (percentage of request) + reason: ValidMetricFound + status: 'True' + type: ScalingActive + - lastTransitionTime: '2020-11-14T23:12:46Z' + message: the desired count is within the acceptable range + reason: DesiredWithinRange + status: 'False' + type: ScalingLimited + currentMetrics: + - resource: + currentAverageUtilization: 12 + currentAverageValue: '65454080' + name: memory + type: Resource + - resource: + currentAverageUtilization: 2 + currentAverageValue: 12m + name: cpu + type: Resource + currentReplicas: 1 + desiredReplicas: 1 + lastScaleTime: '2020-12-07T22:59:53Z' \ No newline at end of file diff --git a/gitops-engine/pkg/health/testdata/hpa-v2beta2-healthy.yaml b/gitops-engine/pkg/health/testdata/hpa-v2beta2-healthy.yaml new file mode 100644 index 0000000000000..9f7b4b8092356 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/hpa-v2beta2-healthy.yaml @@ -0,0 +1,49 @@ +apiVersion: autoscaling/v2beta2 +kind: HorizontalPodAutoscaler +metadata: + creationTimestamp: '2020-08-07T00:13:31Z' + name: credential-hpa + uid: 04d9992e-a849-4cce-9e1e-121a62d5c001 +spec: + maxReplicas: 1 + metrics: + - resource: + name: cpu + target: + averageUtilization: 65 + type: Utilization + type: Resource + minReplicas: 1 + scaleTargetRef: + apiVersion: argoproj.io/v1alpha1 + kind: Rollout + name: credential-rollout +status: + conditions: + - lastTransitionTime: '2020-08-07T00:13:46Z' + message: recommended size matches current size + reason: ReadyForNewScale + status: 'True' + type: AbleToScale + - lastTransitionTime: '2020-12-12T07:13:46Z' + message: >- + the HPA was able to successfully calculate a replica count from cpu + resource utilization (percentage of request) + reason: ValidMetricFound + status: 'True' + type: ScalingActive + - lastTransitionTime: '2020-12-09T23:28:43Z' + message: the desired count is within the acceptable range + reason: DesiredWithinRange + status: 'False' + type: ScalingLimited + currentMetrics: + - resource: + current: + averageUtilization: 27 + averageValue: 195m + name: cpu + type: Resource + currentReplicas: 1 + desiredReplicas: 1 + lastScaleTime: '2020-08-07T00:13:46Z' diff --git a/gitops-engine/pkg/health/testdata/ingress-nonemptylist.yaml b/gitops-engine/pkg/health/testdata/ingress-nonemptylist.yaml new file mode 100644 index 0000000000000..af211d7e34355 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/ingress-nonemptylist.yaml @@ -0,0 +1,29 @@ +apiVersion: networking.k8s.io/v1 +kind: Ingress +metadata: + generation: 1 + labels: + app: grafana + app.kubernetes.io/instance: grafana + chart: grafana-1.12.0 + heritage: Tiller + release: grafana + name: grafana + namespace: test-ops +spec: + rules: + - host: grafana.com + http: + paths: + - backend: + serviceName: grafana + servicePort: 80 + path: / + tls: + - hosts: + - grafana.com + secretName: my-secret +status: + loadBalancer: + ingress: + - {} diff --git a/gitops-engine/pkg/health/testdata/ingress-unassigned.yaml b/gitops-engine/pkg/health/testdata/ingress-unassigned.yaml new file mode 100644 index 0000000000000..585943446c6b5 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/ingress-unassigned.yaml @@ -0,0 +1,24 @@ +apiVersion: networking.k8s.io/v1 +kind: Ingress +metadata: + annotations: + kubernetes.io/ingress.class: nginx + nginx.ingress.kubernetes.io/force-ssl-redirect: "true" + nginx.ingress.kubernetes.io/ssl-passthrough: "true" + creationTimestamp: 2018-09-20T06:47:27Z + generation: 9 + name: argocd-server-ingress + namespace: argocd + resourceVersion: "23207680" + selfLink: /apis/networking.k8s.io/v1/namespaces/argocd/ingresses/argocd-server-ingress + uid: 09927cae-bca1-11e8-bbd2-42010a8a00bb +spec: + rules: + - host: example.argoproj.io + http: + paths: + - backend: + serviceName: argocd-server + servicePort: https +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/health/testdata/ingress.yaml b/gitops-engine/pkg/health/testdata/ingress.yaml new file mode 100644 index 0000000000000..63e1a62797be6 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/ingress.yaml @@ -0,0 +1,26 @@ +apiVersion: networking.k8s.io/v1 +kind: Ingress +metadata: + annotations: + kubernetes.io/ingress.class: nginx + nginx.ingress.kubernetes.io/force-ssl-redirect: "true" + nginx.ingress.kubernetes.io/ssl-passthrough: "true" + creationTimestamp: 2018-09-20T06:47:27Z + generation: 9 + name: argocd-server-ingress + namespace: argocd + resourceVersion: "23207680" + selfLink: /apis/networking.k8s.io/v1/namespaces/argocd/ingresses/argocd-server-ingress + uid: 09927cae-bca1-11e8-bbd2-42010a8a00bb +spec: + rules: + - host: example.argoproj.io + http: + paths: + - backend: + serviceName: argocd-server + servicePort: https +status: + loadBalancer: + ingress: + - ip: 1.2.3.4 diff --git a/gitops-engine/pkg/health/testdata/job-failed.yaml b/gitops-engine/pkg/health/testdata/job-failed.yaml new file mode 100644 index 0000000000000..1deadf93fbe3d --- /dev/null +++ b/gitops-engine/pkg/health/testdata/job-failed.yaml @@ -0,0 +1,52 @@ +apiVersion: batch/v1 +kind: Job +metadata: + creationTimestamp: 2018-12-02T08:09:25Z + labels: + controller-uid: 95052288-f609-11e8-aa53-42010a80021b + job-name: fail + name: fail + namespace: argoci-workflows + resourceVersion: "46534173" + selfLink: /apis/batch/v1/namespaces/argoci-workflows/jobs/fail + uid: 95052288-f609-11e8-aa53-42010a80021b +spec: + backoffLimit: 0 + completions: 1 + parallelism: 1 + selector: + matchLabels: + controller-uid: 95052288-f609-11e8-aa53-42010a80021b + template: + metadata: + creationTimestamp: null + labels: + controller-uid: 95052288-f609-11e8-aa53-42010a80021b + job-name: fail + spec: + containers: + - command: + - sh + - -c + - exit 1 + image: alpine:latest + imagePullPolicy: Always + name: fail + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + conditions: + - lastProbeTime: 2018-12-02T08:09:27Z + lastTransitionTime: 2018-12-02T08:09:27Z + message: Job has reached the specified backoff limit + reason: BackoffLimitExceeded + status: "True" + type: Failed + failed: 1 + startTime: 2018-12-02T08:09:25Z diff --git a/gitops-engine/pkg/health/testdata/job-running.yaml b/gitops-engine/pkg/health/testdata/job-running.yaml new file mode 100644 index 0000000000000..c84527479aa62 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/job-running.yaml @@ -0,0 +1,45 @@ +apiVersion: batch/v1 +kind: Job +metadata: + creationTimestamp: 2018-12-02T08:19:13Z + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + name: succeed + namespace: argoci-workflows + resourceVersion: "46535911" + selfLink: /apis/batch/v1/namespaces/argoci-workflows/jobs/succeed + uid: f3fe3a46-f60a-11e8-aa53-42010a80021b +spec: + backoffLimit: 0 + completions: 1 + parallelism: 1 + selector: + matchLabels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + template: + metadata: + creationTimestamp: null + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + spec: + containers: + - command: + - sh + - -c + - sleep 10 + image: alpine:latest + imagePullPolicy: Always + name: succeed + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + active: 1 + startTime: 2018-12-02T08:19:14Z diff --git a/gitops-engine/pkg/health/testdata/job-succeeded.yaml b/gitops-engine/pkg/health/testdata/job-succeeded.yaml new file mode 100644 index 0000000000000..e8449d6953b42 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/job-succeeded.yaml @@ -0,0 +1,51 @@ +apiVersion: batch/v1 +kind: Job +metadata: + creationTimestamp: 2018-12-02T08:19:13Z + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + name: succeed + namespace: argoci-workflows + resourceVersion: "46535949" + selfLink: /apis/batch/v1/namespaces/argoci-workflows/jobs/succeed + uid: f3fe3a46-f60a-11e8-aa53-42010a80021b +spec: + backoffLimit: 0 + completions: 1 + parallelism: 1 + selector: + matchLabels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + template: + metadata: + creationTimestamp: null + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + spec: + containers: + - command: + - sh + - -c + - sleep 10 + image: alpine:latest + imagePullPolicy: Always + name: succeed + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + completionTime: 2018-12-02T08:19:26Z + conditions: + - lastProbeTime: 2018-12-02T08:19:26Z + lastTransitionTime: 2018-12-02T08:19:26Z + status: "True" + type: Complete + startTime: 2018-12-02T08:19:14Z + succeeded: 1 diff --git a/gitops-engine/pkg/health/testdata/job-suspended.yaml b/gitops-engine/pkg/health/testdata/job-suspended.yaml new file mode 100644 index 0000000000000..7063733069e5f --- /dev/null +++ b/gitops-engine/pkg/health/testdata/job-suspended.yaml @@ -0,0 +1,51 @@ +apiVersion: batch/v1 +kind: Job +metadata: + creationTimestamp: 2018-12-02T08:19:13Z + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + name: succeed + namespace: argoci-workflows + resourceVersion: "46535949" + selfLink: /apis/batch/v1/namespaces/argoci-workflows/jobs/succeed + uid: f3fe3a46-f60a-11e8-aa53-42010a80021b +spec: + backoffLimit: 0 + completions: 1 + parallelism: 1 + selector: + matchLabels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + suspend: true + template: + metadata: + creationTimestamp: null + labels: + controller-uid: f3fe3a46-f60a-11e8-aa53-42010a80021b + job-name: succeed + spec: + containers: + - command: + - sh + - -c + - sleep 10 + image: alpine:latest + imagePullPolicy: Always + name: succeed + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + conditions: + - lastProbeTime: "2022-12-08T22:27:20Z" + lastTransitionTime: "2022-12-08T22:27:20Z" + message: Job suspended + reason: JobSuspended + status: "True" + type: Suspended diff --git a/gitops-engine/pkg/health/testdata/knative-service.yaml b/gitops-engine/pkg/health/testdata/knative-service.yaml new file mode 100644 index 0000000000000..bb4b2e5faec69 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/knative-service.yaml @@ -0,0 +1,14 @@ +apiVersion: serving.knative.dev/v1alpha1 +kind: Service +metadata: + name: helloworld +spec: + runLatest: + configuration: + revisionTemplate: + spec: + container: + env: + - name: TARGET + value: world + image: helloworld:latest diff --git a/gitops-engine/pkg/health/testdata/pod-crashloop.yaml b/gitops-engine/pkg/health/testdata/pod-crashloop.yaml new file mode 100644 index 0000000000000..bc2fe62addb49 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-crashloop.yaml @@ -0,0 +1,86 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:19:36Z + name: my-pod + namespace: argocd + resourceVersion: "151454" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: 63674389-f613-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - exit 1 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://c3aa0064b95a26045999b99c268e715a1c64201e816f1279ac06638778547bb8 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: + terminated: + containerID: docker://c3aa0064b95a26045999b99c268e715a1c64201e816f1279ac06638778547bb8 + exitCode: 1 + finishedAt: 2018-12-02T09:20:25Z + reason: Error + startedAt: 2018-12-02T09:20:25Z + name: main + ready: false + restartCount: 3 + state: + waiting: + message: Back-off 40s restarting failed container=main pod=my-pod_argocd(63674389-f613-11e8-a057-fe5f49266390) + reason: CrashLoopBackOff + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:19:36Z diff --git a/gitops-engine/pkg/health/testdata/pod-deletion.yaml b/gitops-engine/pkg/health/testdata/pod-deletion.yaml new file mode 100644 index 0000000000000..9bc86bd4f4a8b --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-deletion.yaml @@ -0,0 +1,75 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T10:16:04Z + name: image-pull-backoff + namespace: argocd + resourceVersion: "155333" + selfLink: /api/v1/namespaces/argocd/pods/image-pull-backoff + uid: 46c1e8de-f61b-11e8-a057-fe5f49266390 + deletionTimestamp: 2018-12-03T10:16:04Z +spec: + containers: + - image: does-not-exist + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + status: "True" + type: PodScheduled + containerStatuses: + - image: does-not-exist + imageID: "" + lastState: {} + name: main + ready: false + restartCount: 0 + state: + waiting: + reason: PodInitializing + hostIP: 192.168.64.41 + phase: Pending + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T10:16:04Z diff --git a/gitops-engine/pkg/health/testdata/pod-error.yaml b/gitops-engine/pkg/health/testdata/pod-error.yaml new file mode 100644 index 0000000000000..8a8bf9b4b93e6 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-error.yaml @@ -0,0 +1,89 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:19:36Z + name: my-pod + namespace: argocd + resourceVersion: "151396" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: 63674389-f613-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - exit 1 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:19:36Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://fc8dca42fb4f35dac154db3ed45ad7952523345d470b2992779a03c332589ac4 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: + terminated: + containerID: docker://54fe1af9c2c0b61b3697abfeb33adc9ce76ec192b3703b46278d9df7573dff72 + exitCode: 1 + finishedAt: 2018-12-02T09:19:41Z + reason: Error + startedAt: 2018-12-02T09:19:41Z + name: main + ready: false + restartCount: 2 + state: + terminated: + containerID: docker://fc8dca42fb4f35dac154db3ed45ad7952523345d470b2992779a03c332589ac4 + exitCode: 1 + finishedAt: 2018-12-02T09:19:56Z + reason: Error + startedAt: 2018-12-02T09:19:56Z + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:19:36Z diff --git a/gitops-engine/pkg/health/testdata/pod-failed.yaml b/gitops-engine/pkg/health/testdata/pod-failed.yaml new file mode 100644 index 0000000000000..db9718acd36cb --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-failed.yaml @@ -0,0 +1,83 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:17:56Z + name: my-pod + namespace: argocd + resourceVersion: "151243" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: 27c0fdf5-f613-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - exit 1 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:17:56Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:17:56Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:17:56Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://e5f5ce03ecf6d5ad7e131aac09053e5ef6212b067b3d10f3e39ef6e176a3ed60 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: {} + name: main + ready: false + restartCount: 0 + state: + terminated: + containerID: docker://e5f5ce03ecf6d5ad7e131aac09053e5ef6212b067b3d10f3e39ef6e176a3ed60 + exitCode: 1 + finishedAt: 2018-12-02T09:17:59Z + reason: Error + startedAt: 2018-12-02T09:17:59Z + hostIP: 192.168.64.41 + phase: Failed + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:17:56Z diff --git a/gitops-engine/pkg/health/testdata/pod-imagepullbackoff.yaml b/gitops-engine/pkg/health/testdata/pod-imagepullbackoff.yaml new file mode 100644 index 0000000000000..51ef0108beda6 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-imagepullbackoff.yaml @@ -0,0 +1,86 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: "2019-04-04T16:06:55Z" + generateName: guestbook-ui-errimagepullbackoff-66cfffb669- + labels: + app: guestbook-ui + pod-template-hash: "2279996225" + name: guestbook-ui-errimagepullbackoff-66cfffb669-45w2j + namespace: default + ownerReferences: + - apiVersion: extensions/v1beta1 + blockOwnerDeletion: true + controller: true + kind: ReplicaSet + name: guestbook-ui-errimagepullbackoff-66cfffb669 + uid: ab0e507e-56f3-11e9-8721-025000000001 + resourceVersion: "339374" + selfLink: /api/v1/namespaces/default/pods/guestbook-ui-errimagepullbackoff-66cfffb669-45w2j + uid: ab1a9982-56f3-11e9-8721-025000000001 +spec: + containers: + - image: gcr.io/heptio-images/ks-guestbook-demo:0.3 + imagePullPolicy: IfNotPresent + name: errimagepullbackoff + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-7hn5p + readOnly: true + dnsPolicy: ClusterFirst + nodeName: docker-for-desktop + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-7hn5p + secret: + defaultMode: 420 + secretName: default-token-7hn5p +status: + conditions: + - lastProbeTime: null + lastTransitionTime: "2019-04-04T16:06:56Z" + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: "2019-04-04T16:06:56Z" + message: 'containers with unready status: [errimagepullbackoff]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: "2019-04-04T16:06:55Z" + status: "True" + type: PodScheduled + containerStatuses: + - image: gcr.io/heptio-images/ks-guestbook-demo:0.3 + imageID: "" + lastState: {} + name: errimagepullbackoff + ready: false + restartCount: 0 + state: + waiting: + message: Back-off pulling image "gcr.io/heptio-images/ks-guestbook-demo:0.3" + reason: ImagePullBackOff + hostIP: 192.168.65.3 + phase: Pending + podIP: 10.1.0.136 + qosClass: BestEffort + startTime: "2019-04-04T16:06:56Z" diff --git a/gitops-engine/pkg/health/testdata/pod-pending.yaml b/gitops-engine/pkg/health/testdata/pod-pending.yaml new file mode 100644 index 0000000000000..e83303c17f77f --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-pending.yaml @@ -0,0 +1,74 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T10:16:04Z + name: image-pull-backoff + namespace: argocd + resourceVersion: "155333" + selfLink: /api/v1/namespaces/argocd/pods/image-pull-backoff + uid: 46c1e8de-f61b-11e8-a057-fe5f49266390 +spec: + containers: + - image: does-not-exist + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:16:04Z + status: "True" + type: PodScheduled + containerStatuses: + - image: does-not-exist + imageID: "" + lastState: {} + name: main + ready: false + restartCount: 0 + state: + waiting: + reason: PodInitializing + hostIP: 192.168.64.41 + phase: Pending + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T10:16:04Z diff --git a/gitops-engine/pkg/health/testdata/pod-running-not-ready.yaml b/gitops-engine/pkg/health/testdata/pod-running-not-ready.yaml new file mode 100644 index 0000000000000..1ca86dd46aa1a --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-running-not-ready.yaml @@ -0,0 +1,87 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T10:30:57Z + name: never-ready + namespace: argocd + resourceVersion: "156420" + selfLink: /api/v1/namespaces/argocd/pods/never-ready + uid: 5aa62a14-f61d-11e8-a058-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - sleep 9999 + image: alpine:latest + imagePullPolicy: Always + name: main + readinessProbe: + failureThreshold: 3 + initialDelaySeconds: 10 + periodSeconds: 10 + successThreshold: 1 + tcpSocket: + port: 8080 + timeoutSeconds: 1 + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:30:57Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:30:57Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T10:30:57Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://29bc9e85f48af23d5fdcd55fe347350245b584bc11d2b27ebce64d69f26d749a + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: {} + name: main + ready: false + restartCount: 0 + state: + running: + startedAt: 2018-12-02T10:30:59Z + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T10:30:57Z diff --git a/gitops-engine/pkg/health/testdata/pod-running-restart-always.yaml b/gitops-engine/pkg/health/testdata/pod-running-restart-always.yaml new file mode 100644 index 0000000000000..6aa5659166660 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-running-restart-always.yaml @@ -0,0 +1,77 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:24:46Z + name: my-pod + namespace: argocd + resourceVersion: "151753" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: 1c3943ee-f614-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - sleep 99999 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:24:46Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:24:50Z + status: "True" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:24:46Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://be00d86c48878b352f0ae0cae5dd4ba78025726a62893c768a0fd5754f45e93a + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: {} + name: main + ready: true + restartCount: 0 + state: + running: + startedAt: 2018-12-02T09:24:49Z + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:24:46Z diff --git a/gitops-engine/pkg/health/testdata/pod-running-restart-never.yaml b/gitops-engine/pkg/health/testdata/pod-running-restart-never.yaml new file mode 100644 index 0000000000000..a82e47923c379 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-running-restart-never.yaml @@ -0,0 +1,77 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:15:16Z + name: my-pod + namespace: argocd + resourceVersion: "151053" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: c86e909c-f612-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - sleep 10 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:16Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:19Z + status: "True" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:16Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://acfb261d6c1fe8c543438a202de62cb06c137fa93a2d59262d764470e96f3195 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: {} + name: main + ready: true + restartCount: 0 + state: + running: + startedAt: 2018-12-02T09:15:19Z + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:15:16Z diff --git a/gitops-engine/pkg/health/testdata/pod-running-restart-onfailure.yaml b/gitops-engine/pkg/health/testdata/pod-running-restart-onfailure.yaml new file mode 100644 index 0000000000000..2809ee191e17a --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-running-restart-onfailure.yaml @@ -0,0 +1,86 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:47:10Z + name: my-pod + namespace: argocd + resourceVersion: "153419" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: 3cf9325e-f617-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - exit 1 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: OnFailure + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:47:10Z + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:47:10Z + message: 'containers with unready status: [main]' + reason: ContainersNotReady + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:47:10Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://977dcb5c66325385f6df86276a3bcc2419e6aecc0b6682ab90853bd30f21fa51 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: + terminated: + containerID: docker://977dcb5c66325385f6df86276a3bcc2419e6aecc0b6682ab90853bd30f21fa51 + exitCode: 1 + finishedAt: 2018-12-02T09:48:54Z + reason: Error + startedAt: 2018-12-02T09:48:54Z + name: main + ready: false + restartCount: 4 + state: + waiting: + message: Back-off 1m20s restarting failed container=main pod=my-pod_argocd(3cf9325e-f617-11e8-a057-fe5f49266390) + reason: CrashLoopBackOff + hostIP: 192.168.64.41 + phase: Running + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:47:10Z diff --git a/gitops-engine/pkg/health/testdata/pod-succeeded.yaml b/gitops-engine/pkg/health/testdata/pod-succeeded.yaml new file mode 100644 index 0000000000000..de3dc7579ee6f --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pod-succeeded.yaml @@ -0,0 +1,83 @@ +apiVersion: v1 +kind: Pod +metadata: + creationTimestamp: 2018-12-02T09:15:16Z + name: my-pod + namespace: argocd + resourceVersion: "151066" + selfLink: /api/v1/namespaces/argocd/pods/my-pod + uid: c86e909c-f612-11e8-a057-fe5f49266390 +spec: + containers: + - command: + - sh + - -c + - sleep 10 + image: alpine:latest + imagePullPolicy: Always + name: main + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /var/run/secrets/kubernetes.io/serviceaccount + name: default-token-f9jvj + readOnly: true + dnsPolicy: ClusterFirst + nodeName: minikube + restartPolicy: Never + schedulerName: default-scheduler + securityContext: {} + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + tolerations: + - effect: NoExecute + key: node.kubernetes.io/not-ready + operator: Exists + tolerationSeconds: 300 + - effect: NoExecute + key: node.kubernetes.io/unreachable + operator: Exists + tolerationSeconds: 300 + volumes: + - name: default-token-f9jvj + secret: + defaultMode: 420 + secretName: default-token-f9jvj +status: + conditions: + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:16Z + reason: PodCompleted + status: "True" + type: Initialized + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:30Z + reason: PodCompleted + status: "False" + type: Ready + - lastProbeTime: null + lastTransitionTime: 2018-12-02T09:15:16Z + status: "True" + type: PodScheduled + containerStatuses: + - containerID: docker://acfb261d6c1fe8c543438a202de62cb06c137fa93a2d59262d764470e96f3195 + image: alpine:latest + imageID: docker-pullable://alpine@sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528 + lastState: {} + name: main + ready: false + restartCount: 0 + state: + terminated: + containerID: docker://acfb261d6c1fe8c543438a202de62cb06c137fa93a2d59262d764470e96f3195 + exitCode: 0 + finishedAt: 2018-12-02T09:15:29Z + reason: Completed + startedAt: 2018-12-02T09:15:19Z + hostIP: 192.168.64.41 + phase: Succeeded + podIP: 172.17.0.9 + qosClass: BestEffort + startTime: 2018-12-02T09:15:16Z diff --git a/gitops-engine/pkg/health/testdata/pvc-bound.yaml b/gitops-engine/pkg/health/testdata/pvc-bound.yaml new file mode 100644 index 0000000000000..e33919f6a39e7 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pvc-bound.yaml @@ -0,0 +1,34 @@ +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + annotations: + control-plane.alpha.kubernetes.io/leader: '{"holderIdentity":"e57a9040-a984-11e8-836b-c4b301c4d0d1","leaseDurationSeconds":15,"acquireTime":"2018-08-27T23:00:54Z","renewTime":"2018-08-27T23:00:56Z","leaderTransitions":0}' + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"v1","kind":"PersistentVolumeClaim","metadata":{"annotations":{},"labels":{"app.kubernetes.io/instance":"working-pvc"},"name":"testpvc","namespace":"argocd"},"spec":{"accessModes":["ReadWriteOnce"],"resources":{"requests":{"storage":"2Gi"}}}} + pv.kubernetes.io/bind-completed: "yes" + pv.kubernetes.io/bound-by-controller: "yes" + volume.beta.kubernetes.io/storage-provisioner: docker.io/hostpath + creationTimestamp: 2018-08-27T23:00:54Z + finalizers: + - kubernetes.io/pvc-protection + labels: + app.kubernetes.io/instance: working-pvc + name: testpvc + namespace: argocd + resourceVersion: "323170" + selfLink: /api/v1/namespaces/argocd/persistentvolumeclaims/testpvc + uid: 0cedda2c-aa4d-11e8-a271-025000000001 +spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 2Gi + storageClassName: hostpath + volumeName: pvc-0cedda2c-aa4d-11e8-a271-025000000001 +status: + accessModes: + - ReadWriteOnce + capacity: + storage: 2Gi + phase: Bound diff --git a/gitops-engine/pkg/health/testdata/pvc-pending.yaml b/gitops-engine/pkg/health/testdata/pvc-pending.yaml new file mode 100644 index 0000000000000..a5145fc1b92a0 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/pvc-pending.yaml @@ -0,0 +1,26 @@ +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + annotations: + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"v1","kind":"PersistentVolumeClaim","metadata":{"annotations":{},"labels":{"app.kubernetes.io/instance":"working-pvc"},"name":"testpvc-2","namespace":"argocd"},"spec":{"accessModes":["ReadWriteOnce"],"resources":{"requests":{"storage":"2Gi"}},"storageClassName":"slow"}} + volume.beta.kubernetes.io/storage-provisioner: kubernetes.io/aws-ebs + creationTimestamp: 2018-08-27T23:00:54Z + finalizers: + - kubernetes.io/pvc-protection + labels: + app.kubernetes.io/instance: working-pvc + name: testpvc-2 + namespace: argocd + resourceVersion: "323141" + selfLink: /api/v1/namespaces/argocd/persistentvolumeclaims/testpvc-2 + uid: 0cedfc44-aa4d-11e8-a271-025000000001 +spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 2Gi + storageClassName: slow +status: + phase: Pending diff --git a/gitops-engine/pkg/health/testdata/statefulset-ondelete.yaml b/gitops-engine/pkg/health/testdata/statefulset-ondelete.yaml new file mode 100644 index 0000000000000..deb02047f1813 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/statefulset-ondelete.yaml @@ -0,0 +1,123 @@ +apiVersion: apps/v1 +kind: StatefulSet +metadata: + annotations: + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"apps/v1beta2","kind":"StatefulSet","metadata":{"annotations":{},"labels":{"app":"redis","app.kubernetes.io/instance":"redis","chart":"redis-3.6.5","heritage":"Tiller","release":"redis"},"name":"redis-master","namespace":"default"},"spec":{"selector":{"matchLabels":{"app":"redis","release":"redis","role":"master"}},"serviceName":"redis-master","template":{"metadata":{"labels":{"app":"redis","app.kubernetes.io/instance":"redis","release":"redis","role":"master"}},"spec":{"containers":[{"env":[{"name":"REDIS_REPLICATION_MODE","value":"master"},{"name":"REDIS_PASSWORD","valueFrom":{"secretKeyRef":{"key":"redis-password","name":"redis"}}},{"name":"REDIS_DISABLE_COMMANDS","value":"FLUSHDB,FLUSHALL"}],"image":"docker.io/bitnami/redis:4.0.10-debian-9","imagePullPolicy":"Always","livenessProbe":{"exec":{"command":["redis-cli","ping"]},"failureThreshold":5,"initialDelaySeconds":30,"periodSeconds":10,"successThreshold":1,"timeoutSeconds":5},"name":"redis","ports":[{"containerPort":6379,"name":"redis"}],"readinessProbe":{"exec":{"command":["redis-cli","ping"]},"failureThreshold":5,"initialDelaySeconds":5,"periodSeconds":10,"successThreshold":1,"timeoutSeconds":1},"resources":{},"volumeMounts":[{"mountPath":"/bitnami/redis/data","name":"redis-data"}]}],"securityContext":{"fsGroup":1001,"runAsUser":1001},"serviceAccountName":"default"}},"updateStrategy":{"type":"OnDelete"},"volumeClaimTemplates":[{"metadata":{"labels":{"app":"redis","chart":"redis-3.6.5","component":"master","heritage":"Tiller","release":"redis"},"name":"redis-data"},"spec":{"accessModes":["ReadWriteOnce"],"resources":{"requests":{"storage":"8Gi"}}}}]}} + creationTimestamp: 2018-07-20T08:23:04Z + generation: 1 + labels: + app: redis + app.kubernetes.io/instance: redis + chart: redis-3.6.5 + heritage: Tiller + release: redis + name: redis-master + namespace: default + resourceVersion: "514251" + selfLink: /apis/apps/v1/namespaces/default/statefulsets/redis-master + uid: 1f80ab97-8bf6-11e8-aff0-42010a8a0fc6 +spec: + podManagementPolicy: OrderedReady + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: redis + release: redis + role: master + serviceName: redis-master + updateStrategy: + type: OnDelete + template: + metadata: + creationTimestamp: null + labels: + app: redis + app.kubernetes.io/instance: redis + release: redis + role: master + spec: + containers: + - env: + - name: REDIS_REPLICATION_MODE + value: master + - name: REDIS_PASSWORD + valueFrom: + secretKeyRef: + key: redis-password + name: redis + - name: REDIS_DISABLE_COMMANDS + value: FLUSHDB,FLUSHALL + image: docker.io/bitnami/redis:4.0.10-debian-9 + imagePullPolicy: Always + livenessProbe: + exec: + command: + - redis-cli + - ping + failureThreshold: 5 + initialDelaySeconds: 30 + periodSeconds: 10 + successThreshold: 1 + timeoutSeconds: 5 + name: redis + ports: + - containerPort: 6379 + name: redis + protocol: TCP + readinessProbe: + exec: + command: + - redis-cli + - ping + failureThreshold: 5 + initialDelaySeconds: 5 + periodSeconds: 10 + successThreshold: 1 + timeoutSeconds: 1 + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /bitnami/redis/data + name: redis-data + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: + fsGroup: 1001 + runAsUser: 1001 + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + updateStrategy: + type: OnDelete + volumeClaimTemplates: + - kind: PersistentVolumeClaim + apiVersion: v1 + metadata: + creationTimestamp: null + labels: + app: redis + chart: redis-3.6.5 + component: master + heritage: Tiller + release: redis + name: redis-data + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 8Gi + status: + phase: Pending +status: + collisionCount: 0 + currentReplicas: 1 + currentRevision: redis-master-7b8f75b98 + observedGeneration: 1 + readyReplicas: 1 + replicas: 1 + updateRevision: redis-master-7b8f75b98 diff --git a/gitops-engine/pkg/health/testdata/statefulset.yaml b/gitops-engine/pkg/health/testdata/statefulset.yaml new file mode 100644 index 0000000000000..3f058590f8b00 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/statefulset.yaml @@ -0,0 +1,121 @@ +apiVersion: apps/v1 +kind: StatefulSet +metadata: + annotations: + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"apps/v1beta2","kind":"StatefulSet","metadata":{"annotations":{},"labels":{"app":"redis","app.kubernetes.io/instance":"redis","chart":"redis-3.6.5","heritage":"Tiller","release":"redis"},"name":"redis-master","namespace":"default"},"spec":{"selector":{"matchLabels":{"app":"redis","release":"redis","role":"master"}},"serviceName":"redis-master","template":{"metadata":{"labels":{"app":"redis","app.kubernetes.io/instance":"redis","release":"redis","role":"master"}},"spec":{"containers":[{"env":[{"name":"REDIS_REPLICATION_MODE","value":"master"},{"name":"REDIS_PASSWORD","valueFrom":{"secretKeyRef":{"key":"redis-password","name":"redis"}}},{"name":"REDIS_DISABLE_COMMANDS","value":"FLUSHDB,FLUSHALL"}],"image":"docker.io/bitnami/redis:4.0.10-debian-9","imagePullPolicy":"Always","livenessProbe":{"exec":{"command":["redis-cli","ping"]},"failureThreshold":5,"initialDelaySeconds":30,"periodSeconds":10,"successThreshold":1,"timeoutSeconds":5},"name":"redis","ports":[{"containerPort":6379,"name":"redis"}],"readinessProbe":{"exec":{"command":["redis-cli","ping"]},"failureThreshold":5,"initialDelaySeconds":5,"periodSeconds":10,"successThreshold":1,"timeoutSeconds":1},"resources":{},"volumeMounts":[{"mountPath":"/bitnami/redis/data","name":"redis-data"}]}],"securityContext":{"fsGroup":1001,"runAsUser":1001},"serviceAccountName":"default"}},"updateStrategy":{"type":"OnDelete"},"volumeClaimTemplates":[{"metadata":{"labels":{"app":"redis","chart":"redis-3.6.5","component":"master","heritage":"Tiller","release":"redis"},"name":"redis-data"},"spec":{"accessModes":["ReadWriteOnce"],"resources":{"requests":{"storage":"8Gi"}}}}]}} + creationTimestamp: 2018-07-20T08:23:04Z + generation: 1 + labels: + app: redis + app.kubernetes.io/instance: redis + chart: redis-3.6.5 + heritage: Tiller + release: redis + name: redis-master + namespace: default + resourceVersion: "514251" + selfLink: /apis/apps/v1/namespaces/default/statefulsets/redis-master + uid: 1f80ab97-8bf6-11e8-aff0-42010a8a0fc6 +spec: + podManagementPolicy: OrderedReady + replicas: 1 + revisionHistoryLimit: 10 + selector: + matchLabels: + app: redis + release: redis + role: master + serviceName: redis-master + template: + metadata: + creationTimestamp: null + labels: + app: redis + app.kubernetes.io/instance: redis + release: redis + role: master + spec: + containers: + - env: + - name: REDIS_REPLICATION_MODE + value: master + - name: REDIS_PASSWORD + valueFrom: + secretKeyRef: + key: redis-password + name: redis + - name: REDIS_DISABLE_COMMANDS + value: FLUSHDB,FLUSHALL + image: docker.io/bitnami/redis:4.0.10-debian-9 + imagePullPolicy: Always + livenessProbe: + exec: + command: + - redis-cli + - ping + failureThreshold: 5 + initialDelaySeconds: 30 + periodSeconds: 10 + successThreshold: 1 + timeoutSeconds: 5 + name: redis + ports: + - containerPort: 6379 + name: redis + protocol: TCP + readinessProbe: + exec: + command: + - redis-cli + - ping + failureThreshold: 5 + initialDelaySeconds: 5 + periodSeconds: 10 + successThreshold: 1 + timeoutSeconds: 1 + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + volumeMounts: + - mountPath: /bitnami/redis/data + name: redis-data + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: + fsGroup: 1001 + runAsUser: 1001 + serviceAccount: default + serviceAccountName: default + terminationGracePeriodSeconds: 30 + updateStrategy: + type: OnDelete + volumeClaimTemplates: + - kind: PersistentVolumeClaim + apiVersion: v1 + metadata: + creationTimestamp: null + labels: + app: redis + chart: redis-3.6.5 + component: master + heritage: Tiller + release: redis + name: redis-data + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 8Gi + status: + phase: Pending +status: + collisionCount: 0 + currentReplicas: 1 + currentRevision: redis-master-7b8f75b98 + observedGeneration: 1 + readyReplicas: 1 + replicas: 1 + updateRevision: redis-master-7b8f75b98 diff --git a/gitops-engine/pkg/health/testdata/svc-clusterip.yaml b/gitops-engine/pkg/health/testdata/svc-clusterip.yaml new file mode 100644 index 0000000000000..fb3e4bb0943e6 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/svc-clusterip.yaml @@ -0,0 +1,25 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + kubectl.kubernetes.io/last-applied-configuration: | + {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"name":"argocd-metrics","namespace":"argocd"},"spec":{"ports":[{"name":"http","port":8082,"protocol":"TCP","targetPort":8082}],"selector":{"app":"argocd-server"}}} + creationTimestamp: 2018-10-27T06:36:27Z + name: argocd-metrics + namespace: argocd + resourceVersion: "1131" + selfLink: /api/v1/namespaces/argocd/services/argocd-metrics + uid: a1f65069-d9b2-11e8-b3c1-9ae2f452bd03 +spec: + clusterIP: 10.96.199.2 + ports: + - name: http + port: 8082 + protocol: TCP + targetPort: 8082 + selector: + app: argocd-server + sessionAffinity: None + type: ClusterIP +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/health/testdata/svc-loadbalancer-nonemptylist.yaml b/gitops-engine/pkg/health/testdata/svc-loadbalancer-nonemptylist.yaml new file mode 100644 index 0000000000000..273bd2ccb5ac1 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/svc-loadbalancer-nonemptylist.yaml @@ -0,0 +1,35 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + service.beta.kubernetes.io/aws-load-balancer-connection-idle-timeout: "600" + creationTimestamp: 2018-06-05T23:34:58Z + labels: + app.kubernetes.io/instance: argocd-cdp + name: argocd-server + namespace: argocd + resourceVersion: "32559487" + selfLink: /api/v1/namespaces/argocd/services/argocd-server + uid: 0f5885a9-6919-11e8-ad29-020124679688 +spec: + clusterIP: 100.69.46.185 + externalTrafficPolicy: Cluster + ports: + - name: http + nodePort: 30354 + port: 80 + protocol: TCP + targetPort: 8080 + - name: https + nodePort: 31866 + port: 443 + protocol: TCP + targetPort: 8080 + selector: + app: argocd-server + sessionAffinity: None + type: LoadBalancer +status: + loadBalancer: + ingress: + - {} diff --git a/gitops-engine/pkg/health/testdata/svc-loadbalancer-unassigned.yaml b/gitops-engine/pkg/health/testdata/svc-loadbalancer-unassigned.yaml new file mode 100644 index 0000000000000..b029ac14694d5 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/svc-loadbalancer-unassigned.yaml @@ -0,0 +1,25 @@ +apiVersion: v1 +kind: Service +metadata: + creationTimestamp: 2018-11-06T01:07:35Z + name: argo-artifacts + namespace: argo + resourceVersion: "346792" + selfLink: /api/v1/namespaces/argo/services/argo-artifacts + uid: 586f5e57-e160-11e8-b3c1-9ae2f452bd03 +spec: + clusterIP: 10.105.70.181 + externalTrafficPolicy: Cluster + ports: + - name: service + nodePort: 32667 + port: 9000 + protocol: TCP + targetPort: 9000 + selector: + app: minio + release: argo-artifacts + sessionAffinity: None + type: LoadBalancer +status: + loadBalancer: {} diff --git a/gitops-engine/pkg/health/testdata/svc-loadbalancer.yaml b/gitops-engine/pkg/health/testdata/svc-loadbalancer.yaml new file mode 100644 index 0000000000000..c1d5b7fd082b5 --- /dev/null +++ b/gitops-engine/pkg/health/testdata/svc-loadbalancer.yaml @@ -0,0 +1,35 @@ +apiVersion: v1 +kind: Service +metadata: + annotations: + service.beta.kubernetes.io/aws-load-balancer-connection-idle-timeout: "600" + creationTimestamp: 2018-06-05T23:34:58Z + labels: + app.kubernetes.io/instance: argocd-cdp + name: argocd-server + namespace: argocd + resourceVersion: "32559487" + selfLink: /api/v1/namespaces/argocd/services/argocd-server + uid: 0f5885a9-6919-11e8-ad29-020124679688 +spec: + clusterIP: 100.69.46.185 + externalTrafficPolicy: Cluster + ports: + - name: http + nodePort: 30354 + port: 80 + protocol: TCP + targetPort: 8080 + - name: https + nodePort: 31866 + port: 443 + protocol: TCP + targetPort: 8080 + selector: + app: argocd-server + sessionAffinity: None + type: LoadBalancer +status: + loadBalancer: + ingress: + - hostname: abc123.us-west-2.elb.amazonaws.com diff --git a/gitops-engine/pkg/sync/common/types.go b/gitops-engine/pkg/sync/common/types.go new file mode 100644 index 0000000000000..00976ff5d1f4b --- /dev/null +++ b/gitops-engine/pkg/sync/common/types.go @@ -0,0 +1,169 @@ +package common + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +const ( + // AnnotationSyncOptions is a comma-separated list of options for syncing + AnnotationSyncOptions = "argocd.argoproj.io/sync-options" + // AnnotationSyncWave indicates which wave of the sync the resource or hook should be in + AnnotationSyncWave = "argocd.argoproj.io/sync-wave" + // AnnotationKeyHook contains the hook type of a resource + AnnotationKeyHook = "argocd.argoproj.io/hook" + // AnnotationKeyHookDeletePolicy is the policy of deleting a hook + AnnotationKeyHookDeletePolicy = "argocd.argoproj.io/hook-delete-policy" + AnnotationDeletionApproved = "argocd.argoproj.io/deletion-approved" + + // Sync option that disables dry run in resource is missing in the cluster + SyncOptionSkipDryRunOnMissingResource = "SkipDryRunOnMissingResource=true" + // Sync option that disables resource pruning + SyncOptionDisablePrune = "Prune=false" + // Sync option that disables resource validation + SyncOptionsDisableValidation = "Validate=false" + // Sync option that enables pruneLast + SyncOptionPruneLast = "PruneLast=true" + // Sync option that enables use of replace or create command instead of apply + SyncOptionReplace = "Replace=true" + // Sync option that disables use of replace or create command instead of apply + SyncOptionDisableReplace = "Replace=false" + // Sync option that enables use of --force flag, delete and re-create + SyncOptionForce = "Force=true" + // Sync option that enables use of --server-side flag instead of client-side + SyncOptionServerSideApply = "ServerSideApply=true" + // Sync option that disables use of --server-side flag instead of client-side + SyncOptionDisableServerSideApply = "ServerSideApply=false" + // Sync option that disables resource deletion + SyncOptionDisableDeletion = "Delete=false" + // Sync option that sync only out of sync resources + SyncOptionApplyOutOfSyncOnly = "ApplyOutOfSyncOnly=true" + // Sync option that disables sync only out of sync resources + SyncOptionDisableApplyOutOfSyncOnly = "ApplyOutOfSyncOnly=false" + // Sync option that requires confirmation before deleting the resource + SyncOptionDeleteRequireConfirm = "Delete=confirm" + // Sync option that requires confirmation before deleting the resource + SyncOptionPruneRequireConfirm = "Prune=confirm" + // Sync option that enables client-side apply migration + SyncOptionClientSideApplyMigration = "ClientSideApplyMigration=true" + // Sync option that disables client-side apply migration + SyncOptionDisableClientSideApplyMigration = "ClientSideApplyMigration=false" + + // Default field manager for client-side apply migration + DefaultClientSideApplyMigrationManager = "kubectl-client-side-apply" +) + +type PermissionValidator func(un *unstructured.Unstructured, res *metav1.APIResource) error + +type SyncPhase string + +// SyncWaveHook is a callback function which will be invoked after each sync wave is successfully +// applied during a sync operation. The callback indicates which phase and wave it had just +// executed, and whether or not that wave was the final one. +type SyncWaveHook func(phase SyncPhase, wave int, final bool) error + +const ( + SyncPhasePreSync = "PreSync" + SyncPhaseSync = "Sync" + SyncPhasePostSync = "PostSync" + SyncPhaseSyncFail = "SyncFail" +) + +type OperationPhase string + +const ( + OperationRunning OperationPhase = "Running" + OperationTerminating OperationPhase = "Terminating" + OperationFailed OperationPhase = "Failed" + OperationError OperationPhase = "Error" + OperationSucceeded OperationPhase = "Succeeded" +) + +func (os OperationPhase) Completed() bool { + switch os { + case OperationFailed, OperationError, OperationSucceeded: + return true + } + return false +} + +func (os OperationPhase) Running() bool { + return os == OperationRunning +} + +func (os OperationPhase) Successful() bool { + return os == OperationSucceeded +} + +func (os OperationPhase) Failed() bool { + return os == OperationFailed +} + +type ResultCode string + +const ( + ResultCodeSynced ResultCode = "Synced" + ResultCodeSyncFailed ResultCode = "SyncFailed" + ResultCodePruned ResultCode = "Pruned" + ResultCodePruneSkipped ResultCode = "PruneSkipped" +) + +type HookType string + +const ( + HookTypePreSync HookType = "PreSync" + HookTypeSync HookType = "Sync" + HookTypePostSync HookType = "PostSync" + HookTypeSkip HookType = "Skip" + HookTypeSyncFail HookType = "SyncFail" +) + +func NewHookType(t string) (HookType, bool) { + return HookType(t), + t == string(HookTypePreSync) || + t == string(HookTypeSync) || + t == string(HookTypePostSync) || + t == string(HookTypeSyncFail) || + t == string(HookTypeSkip) +} + +type HookDeletePolicy string + +const ( + HookDeletePolicyHookSucceeded HookDeletePolicy = "HookSucceeded" + HookDeletePolicyHookFailed HookDeletePolicy = "HookFailed" + HookDeletePolicyBeforeHookCreation HookDeletePolicy = "BeforeHookCreation" +) + +func NewHookDeletePolicy(p string) (HookDeletePolicy, bool) { + return HookDeletePolicy(p), + p == string(HookDeletePolicyHookSucceeded) || + p == string(HookDeletePolicyHookFailed) || + p == string(HookDeletePolicyBeforeHookCreation) +} + +type ResourceSyncResult struct { + // holds associated resource key + ResourceKey kube.ResourceKey + // Images holds the images associated with the resource. These images are collected on a best-effort basis + // from fields used by known workload resources. This does not necessarily reflect the exact list of images + // used by workloads in the application. + Images []string + // holds resource version + Version string + // holds the execution order + Order int + // result code + Status ResultCode + // message for the last sync OR operation + Message string + // the type of the hook, empty for non-hook resources + HookType HookType + // the state of any operation associated with this resource OR hook + // note: can contain values for non-hook resources + HookPhase OperationPhase + // indicates the particular phase of the sync that this is for + SyncPhase SyncPhase +} diff --git a/gitops-engine/pkg/sync/common/types_test.go b/gitops-engine/pkg/sync/common/types_test.go new file mode 100644 index 0000000000000..339650a74b212 --- /dev/null +++ b/gitops-engine/pkg/sync/common/types_test.go @@ -0,0 +1,51 @@ +package common + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNewHookType(t *testing.T) { + t.Run("Garbage", func(t *testing.T) { + _, ok := NewHookType("Garbage") + assert.False(t, ok) + }) + t.Run("PreSync", func(t *testing.T) { + hookType, ok := NewHookType("PreSync") + assert.True(t, ok) + assert.Equal(t, HookTypePreSync, hookType) + }) + t.Run("Sync", func(t *testing.T) { + hookType, ok := NewHookType("Sync") + assert.True(t, ok) + assert.Equal(t, HookTypeSync, hookType) + }) + t.Run("PostSync", func(t *testing.T) { + hookType, ok := NewHookType("PostSync") + assert.True(t, ok) + assert.Equal(t, HookTypePostSync, hookType) + }) +} + +func TestNewHookDeletePolicy(t *testing.T) { + t.Run("Garbage", func(t *testing.T) { + _, ok := NewHookDeletePolicy("Garbage") + assert.False(t, ok) + }) + t.Run("HookSucceeded", func(t *testing.T) { + p, ok := NewHookDeletePolicy("HookSucceeded") + assert.True(t, ok) + assert.Equal(t, HookDeletePolicyHookSucceeded, p) + }) + t.Run("HookFailed", func(t *testing.T) { + p, ok := NewHookDeletePolicy("HookFailed") + assert.True(t, ok) + assert.Equal(t, HookDeletePolicyHookFailed, p) + }) + t.Run("BeforeHookCreation", func(t *testing.T) { + p, ok := NewHookDeletePolicy("BeforeHookCreation") + assert.True(t, ok) + assert.Equal(t, HookDeletePolicyBeforeHookCreation, p) + }) +} diff --git a/gitops-engine/pkg/sync/doc.go b/gitops-engine/pkg/sync/doc.go new file mode 100644 index 0000000000000..f4f5d87252d4d --- /dev/null +++ b/gitops-engine/pkg/sync/doc.go @@ -0,0 +1,104 @@ +/* +Package implements Kubernetes resources synchronization and provides the following main features: + - basic syncing + - resource pruning + - resource hooks + - sync waves + - sync options + +# Basic Syncing + +Executes equivalent of `kubectl apply` for each specified resource. The apply operations are executed in the predefined +order depending of resource type: namespaces, custom resource definitions first and workload resources last. + +# Resource Pruning + +An ability to delete resources that no longer should exist in the cluster. By default obsolete resources are not deleted +and only reported in the sync operation result. + +# Resource Hooks + +Hooks provide an ability to create resources such as Pod, Job or any other resource, that are 'executed' before, after +or even during the synchronization process. Hooks enable use-cases such as database migration and post sync notifications. + +Hooks are regular Kubernetes resources that have `argocd.argoproj.io/hook` annotation: + + apiVersion: batch/v1 + kind: Job + metadata: + generateName: schema-migrate- + annotations: + argocd.argoproj.io/hook: PreSync + +The annotation value indicates the sync operation phase: + + - PreSync - executes prior to the apply of the manifests. + - PostSync - executes after all Sync hooks completed and were successful, a successful apply, and all resources in a Healthy state. + - SyncFail - executes when the sync operation fails. + - Sync - executes after all PreSync hooks completed and were successful, at the same time as the apply of the manifests. + +Named hooks (i.e. ones with /metadata/name) will only be created once. If you want a hook to be re-created each time +either use BeforeHookCreation policy (see below) or /metadata/generateName. + +The same resource hook might be executed in several sync phases: + + apiVersion: batch/v1 + kind: Job + metadata: + generateName: schema-migrate- + annotations: + argocd.argoproj.io/hook: PreSync,PostSync + +Hooks can be deleted in an automatic fashion using the annotation: argocd.argoproj.io/hook-delete-policy. + + apiVersion: batch/v1 + kind: Job + metadata: + generateName: integration-test- + annotations: + argocd.argoproj.io/hook: PostSync + argocd.argoproj.io/hook-delete-policy: HookSucceeded + +The following policies define when the hook will be deleted. + + - HookSucceeded - the hook resource is deleted after the hook succeeded (e.g. Job/Workflow completed successfully). + - HookFailed - the hook resource is deleted after the hook failed. + - BeforeHookCreation - any existing hook resource is deleted before the new one is created + +# Sync Waves + +The waves allow to group sync execution of syncing process into batches when each batch is executed sequentially one after +another. Hooks and resources are assigned to wave zero by default. The wave can be negative, so you can create a wave +that runs before all other resources. The `argocd.argoproj.io/sync-wave` annotation assign resource to a wave: + + metadata: + annotations: + argocd.argoproj.io/sync-wave: "5" + +# Sync Options + +The sync options allows customizing the synchronization of selected resources. The options are specified using the +annotation 'argocd.argoproj.io/sync-options'. Following sync options are supported: + +- SkipDryRunOnMissingResource=true - disables dry run in resource is missing in the cluster +- Prune=false - disables resource pruning +- Validate=false - disables resource validation (equivalent to 'kubectl apply --validate=false') + +How Does It Work Together? + +Syncing process orders the resources in the following precedence: + +- The phase +- The wave they are in (lower values first) +- By kind (e.g. namespaces first) +- By name + +It then determines which the number of the next wave to apply. This is the first number where any resource is +out-of-sync or unhealthy. It applies resources in that wave. It repeats this process until all phases and waves are in +in-sync and healthy. + +# Example + +Find real-life example in https://github.com/argoproj/gitops-engine/blob/master/pkg/engine/engine.go +*/ +package sync diff --git a/gitops-engine/pkg/sync/hook/delete_policy.go b/gitops-engine/pkg/sync/hook/delete_policy.go new file mode 100644 index 0000000000000..56a9e15c8ab33 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/delete_policy.go @@ -0,0 +1,26 @@ +package hook + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + helmhook "github.com/argoproj/gitops-engine/pkg/sync/hook/helm" + resourceutil "github.com/argoproj/gitops-engine/pkg/sync/resource" +) + +func DeletePolicies(obj *unstructured.Unstructured) []common.HookDeletePolicy { + var policies []common.HookDeletePolicy + for _, text := range resourceutil.GetAnnotationCSVs(obj, common.AnnotationKeyHookDeletePolicy) { + p, ok := common.NewHookDeletePolicy(text) + if ok { + policies = append(policies, p) + } + } + for _, p := range helmhook.DeletePolicies(obj) { + policies = append(policies, p.DeletePolicy()) + } + if len(policies) == 0 { + policies = append(policies, common.HookDeletePolicyBeforeHookCreation) + } + return policies +} diff --git a/gitops-engine/pkg/sync/hook/delete_policy_test.go b/gitops-engine/pkg/sync/hook/delete_policy_test.go new file mode 100644 index 0000000000000..faa31e3faa888 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/delete_policy_test.go @@ -0,0 +1,20 @@ +package hook + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestDeletePolicies(t *testing.T) { + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyBeforeHookCreation}, DeletePolicies(testingutils.NewPod())) + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyBeforeHookCreation}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "garbage"))) + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyBeforeHookCreation}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation"))) + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyHookSucceeded}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "HookSucceeded"))) + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyHookFailed}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "HookFailed"))) + // Helm test + assert.Equal(t, []common.HookDeletePolicy{common.HookDeletePolicyHookSucceeded}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-delete-policy", "hook-succeeded"))) +} diff --git a/gitops-engine/pkg/sync/hook/helm/delete_policy.go b/gitops-engine/pkg/sync/hook/helm/delete_policy.go new file mode 100644 index 0000000000000..f174eda7d9143 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/delete_policy.go @@ -0,0 +1,42 @@ +package helm + +import ( + "github.com/argoproj/gitops-engine/pkg/sync/common" + resourceutil "github.com/argoproj/gitops-engine/pkg/sync/resource" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +type DeletePolicy string + +const ( + BeforeHookCreation DeletePolicy = "before-hook-creation" + HookSucceeded DeletePolicy = "hook-succeeded" + HookFailed DeletePolicy = "hook-failed" +) + +// note that we do not take into account if this is or is not a hook, caller should check +func NewDeletePolicy(p string) (DeletePolicy, bool) { + return DeletePolicy(p), p == string(BeforeHookCreation) || p == string(HookSucceeded) || p == string(HookFailed) +} + +var hookDeletePolicies = map[DeletePolicy]common.HookDeletePolicy{ + BeforeHookCreation: common.HookDeletePolicyBeforeHookCreation, + HookSucceeded: common.HookDeletePolicyHookSucceeded, + HookFailed: common.HookDeletePolicyHookFailed, +} + +func (p DeletePolicy) DeletePolicy() common.HookDeletePolicy { + return hookDeletePolicies[p] +} + +func DeletePolicies(obj *unstructured.Unstructured) []DeletePolicy { + var policies []DeletePolicy + for _, text := range resourceutil.GetAnnotationCSVs(obj, "helm.sh/hook-delete-policy") { + p, ok := NewDeletePolicy(text) + if ok { + policies = append(policies, p) + } + } + return policies +} diff --git a/gitops-engine/pkg/sync/hook/helm/delete_policy_test.go b/gitops-engine/pkg/sync/hook/helm/delete_policy_test.go new file mode 100644 index 0000000000000..019ff9f2595f6 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/delete_policy_test.go @@ -0,0 +1,23 @@ +package helm + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestDeletePolicies(t *testing.T) { + assert.Nil(t, DeletePolicies(testingutils.NewPod())) + assert.Equal(t, []DeletePolicy{BeforeHookCreation}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-delete-policy", "before-hook-creation"))) + assert.Equal(t, []DeletePolicy{HookSucceeded}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-delete-policy", "hook-succeeded"))) + assert.Equal(t, []DeletePolicy{HookFailed}, DeletePolicies(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-delete-policy", "hook-failed"))) +} + +func TestDeletePolicy_DeletePolicy(t *testing.T) { + assert.Equal(t, common.HookDeletePolicyBeforeHookCreation, BeforeHookCreation.DeletePolicy()) + assert.Equal(t, common.HookDeletePolicyHookSucceeded, HookSucceeded.DeletePolicy()) + assert.Equal(t, common.HookDeletePolicyHookFailed, HookFailed.DeletePolicy()) +} diff --git a/gitops-engine/pkg/sync/hook/helm/hook.go b/gitops-engine/pkg/sync/hook/helm/hook.go new file mode 100644 index 0000000000000..9b33399198dbe --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/hook.go @@ -0,0 +1,9 @@ +package helm + +import "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + +func IsHook(obj *unstructured.Unstructured) bool { + value, ok := obj.GetAnnotations()["helm.sh/hook"] + // Helm use the same annotation to identify CRD as hooks, but they are not. + return ok && value != "crd-install" +} diff --git a/gitops-engine/pkg/sync/hook/helm/hook_test.go b/gitops-engine/pkg/sync/hook/helm/hook_test.go new file mode 100644 index 0000000000000..1e3e9470072ba --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/hook_test.go @@ -0,0 +1,16 @@ +package helm + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestIsHook(t *testing.T) { + assert.False(t, IsHook(testingutils.NewPod())) + assert.True(t, IsHook(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "anything"))) + // helm calls "crd-install" a hook, but it really can't be treated as such + assert.False(t, IsHook(testingutils.Annotate(testingutils.NewCRD(), "helm.sh/hook", "crd-install"))) +} diff --git a/gitops-engine/pkg/sync/hook/helm/type.go b/gitops-engine/pkg/sync/hook/helm/type.go new file mode 100644 index 0000000000000..f94f3bc47bf01 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/type.go @@ -0,0 +1,47 @@ +package helm + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + resourceutil "github.com/argoproj/gitops-engine/pkg/sync/resource" +) + +type Type string + +const ( + PreInstall Type = "pre-install" + PreUpgrade Type = "pre-upgrade" + PostUpgrade Type = "post-upgrade" + PostInstall Type = "post-install" +) + +func NewType(t string) (Type, bool) { + return Type(t), + t == string(PreInstall) || + t == string(PreUpgrade) || + t == string(PostUpgrade) || + t == string(PostInstall) +} + +var hookTypes = map[Type]common.HookType{ + PreInstall: common.HookTypePreSync, + PreUpgrade: common.HookTypePreSync, + PostUpgrade: common.HookTypePostSync, + PostInstall: common.HookTypePostSync, +} + +func (t Type) HookType() common.HookType { + return hookTypes[t] +} + +func Types(obj *unstructured.Unstructured) []Type { + var types []Type + for _, text := range resourceutil.GetAnnotationCSVs(obj, "helm.sh/hook") { + t, ok := NewType(text) + if ok { + types = append(types, t) + } + } + return types +} diff --git a/gitops-engine/pkg/sync/hook/helm/type_test.go b/gitops-engine/pkg/sync/hook/helm/type_test.go new file mode 100644 index 0000000000000..c50777e800a08 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/type_test.go @@ -0,0 +1,32 @@ +package helm + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestTypes(t *testing.T) { + assert.Nil(t, Types(testingutils.NewPod())) + assert.Equal(t, []Type{PreInstall}, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "pre-install"))) + assert.Equal(t, []Type{PreUpgrade}, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "pre-upgrade"))) + assert.Equal(t, []Type{PostUpgrade}, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "post-upgrade"))) + assert.Equal(t, []Type{PostInstall}, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "post-install"))) + // helm calls "crd-install" a hook, but it really can't be treated as such + assert.Empty(t, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "crd-install"))) + // we do not consider these supported hooks + assert.Nil(t, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "pre-rollback"))) + assert.Nil(t, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "post-rollback"))) + assert.Nil(t, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "test-success"))) + assert.Nil(t, Types(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "test-failure"))) +} + +func TestType_HookType(t *testing.T) { + assert.Equal(t, common.HookTypePreSync, PreInstall.HookType()) + assert.Equal(t, common.HookTypePreSync, PreUpgrade.HookType()) + assert.Equal(t, common.HookTypePostSync, PostUpgrade.HookType()) + assert.Equal(t, common.HookTypePostSync, PostInstall.HookType()) +} diff --git a/gitops-engine/pkg/sync/hook/helm/weight.go b/gitops-engine/pkg/sync/hook/helm/weight.go new file mode 100644 index 0000000000000..15ecfdf202326 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/weight.go @@ -0,0 +1,19 @@ +package helm + +import ( + "strconv" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +// note that we do not take into account if this is or is not a hook, caller should check +func Weight(obj *unstructured.Unstructured) int { + text, ok := obj.GetAnnotations()["helm.sh/hook-weight"] + if ok { + value, err := strconv.Atoi(text) + if err == nil { + return value + } + } + return 0 +} diff --git a/gitops-engine/pkg/sync/hook/helm/weight_test.go b/gitops-engine/pkg/sync/hook/helm/weight_test.go new file mode 100644 index 0000000000000..ab971ee11a149 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/helm/weight_test.go @@ -0,0 +1,14 @@ +package helm + +import ( + "testing" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" + + "github.com/stretchr/testify/assert" +) + +func TestWeight(t *testing.T) { + assert.Equal(t, 0, Weight(testingutils.NewPod())) + assert.Equal(t, 1, Weight(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-weight", "1"))) +} diff --git a/gitops-engine/pkg/sync/hook/hook.go b/gitops-engine/pkg/sync/hook/hook.go new file mode 100644 index 0000000000000..66dfc26e50b66 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/hook.go @@ -0,0 +1,58 @@ +package hook + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + helmhook "github.com/argoproj/gitops-engine/pkg/sync/hook/helm" + resourceutil "github.com/argoproj/gitops-engine/pkg/sync/resource" +) + +const ( + // HookFinalizer is the finalizer added to hooks to ensure they are deleted only after the sync phase is completed. + HookFinalizer = "argocd.argoproj.io/hook-finalizer" +) + +func HasHookFinalizer(obj *unstructured.Unstructured) bool { + finalizers := obj.GetFinalizers() + for _, finalizer := range finalizers { + if finalizer == HookFinalizer { + return true + } + } + return false +} + +func IsHook(obj *unstructured.Unstructured) bool { + _, ok := obj.GetAnnotations()[common.AnnotationKeyHook] + if ok { + return !Skip(obj) + } + return helmhook.IsHook(obj) +} + +func Skip(obj *unstructured.Unstructured) bool { + for _, hookType := range Types(obj) { + if hookType == common.HookTypeSkip { + return len(Types(obj)) == 1 + } + } + return false +} + +func Types(obj *unstructured.Unstructured) []common.HookType { + var types []common.HookType + for _, text := range resourceutil.GetAnnotationCSVs(obj, common.AnnotationKeyHook) { + t, ok := common.NewHookType(text) + if ok { + types = append(types, t) + } + } + // we ignore Helm hooks if we have Argo hook + if len(types) == 0 { + for _, t := range helmhook.Types(obj) { + types = append(types, t.HookType()) + } + } + return types +} diff --git a/gitops-engine/pkg/sync/hook/hook_test.go b/gitops-engine/pkg/sync/hook/hook_test.go new file mode 100644 index 0000000000000..dc4b51a217c62 --- /dev/null +++ b/gitops-engine/pkg/sync/hook/hook_test.go @@ -0,0 +1,98 @@ +package hook + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestNoHooks(t *testing.T) { + obj := &unstructured.Unstructured{} + assert.False(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Nil(t, Types(obj)) +} + +func TestOneHook(t *testing.T) { + hookTypesString := []string{"PreSync", "Sync", "PostSync", "SyncFail"} + hookTypes := []common.HookType{common.HookTypePreSync, common.HookTypeSync, common.HookTypePostSync, common.HookTypeSyncFail} + for i, hook := range hookTypesString { + obj := example(hook) + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Equal(t, []common.HookType{hookTypes[i]}, Types(obj)) + } +} + +// peculiar case of something marked with "Skip" cannot, by definition, be a hook +// IMHO this is bad design as it conflates a flag on something that can never be a hook, with something that is +// always a hook, creating a nasty exception we always need to check for, and a bunch of horrible edge cases +func TestSkipHook(t *testing.T) { + obj := example("Skip") + assert.False(t, IsHook(obj)) + assert.True(t, Skip(obj)) + assert.Equal(t, []common.HookType{common.HookTypeSkip}, Types(obj)) +} + +// we treat garbage as the user intended you to be a hook, but spelled it wrong, so you are a hook, but we don't +// know what phase you're a part of +func TestGarbageHook(t *testing.T) { + obj := example("Garbage") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Nil(t, Types(obj)) +} + +func TestTwoHooks(t *testing.T) { + obj := example("PreSync,PostSync") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.ElementsMatch(t, []common.HookType{common.HookTypePreSync, common.HookTypePostSync}, Types(obj)) +} + +func TestDupHookTypes(t *testing.T) { + assert.Equal(t, []common.HookType{common.HookTypeSync}, Types(example("Sync,Sync"))) +} + +// horrible edge case +func TestSkipAndHook(t *testing.T) { + obj := example("Skip,PreSync,PostSync") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.ElementsMatch(t, []common.HookType{common.HookTypeSkip, common.HookTypePreSync, common.HookTypePostSync}, Types(obj)) +} + +func TestGarbageAndHook(t *testing.T) { + obj := example("Sync,Garbage") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Equal(t, []common.HookType{common.HookTypeSync}, Types(obj)) +} + +func TestHelmHook(t *testing.T) { + obj := testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "pre-install") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Equal(t, []common.HookType{common.HookTypePreSync}, Types(obj)) +} + +func TestGarbageHelmHook(t *testing.T) { + obj := testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", "garbage") + assert.True(t, IsHook(obj)) + assert.False(t, Skip(obj)) + assert.Nil(t, Types(obj)) +} + +// we should ignore Helm hooks if we have an Argo CD hook +func TestBothHooks(t *testing.T) { + obj := testingutils.Annotate(example("Sync"), "helm.sh/hook", "pre-install") + assert.Equal(t, []common.HookType{common.HookTypeSync}, Types(obj)) +} + +func example(hook string) *unstructured.Unstructured { + return testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", hook) +} diff --git a/gitops-engine/pkg/sync/ignore/ignore.go b/gitops-engine/pkg/sync/ignore/ignore.go new file mode 100644 index 0000000000000..e7ea36defeedf --- /dev/null +++ b/gitops-engine/pkg/sync/ignore/ignore.go @@ -0,0 +1,12 @@ +package ignore + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/hook" +) + +// should we Ignore this resource? +func Ignore(obj *unstructured.Unstructured) bool { + return hook.IsHook(obj) && len(hook.Types(obj)) == 0 +} diff --git a/gitops-engine/pkg/sync/ignore/ignore_test.go b/gitops-engine/pkg/sync/ignore/ignore_test.go new file mode 100644 index 0000000000000..49ab65c3d7146 --- /dev/null +++ b/gitops-engine/pkg/sync/ignore/ignore_test.go @@ -0,0 +1,25 @@ +package ignore + +import ( + "testing" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + + "github.com/stretchr/testify/assert" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func newHook(obj *unstructured.Unstructured, hookType common.HookType) *unstructured.Unstructured { + return testingutils.Annotate(obj, "argocd.argoproj.io/hook", string(hookType)) +} + +func TestIgnore(t *testing.T) { + assert.False(t, Ignore(testingutils.NewPod())) + assert.False(t, Ignore(newHook(testingutils.NewPod(), "Sync"))) + assert.True(t, Ignore(newHook(testingutils.NewPod(), "garbage"))) + assert.False(t, Ignore(testingutils.HelmHook(testingutils.NewPod(), "pre-install"))) + assert.True(t, Ignore(testingutils.HelmHook(testingutils.NewPod(), "garbage"))) +} diff --git a/gitops-engine/pkg/sync/reconcile.go b/gitops-engine/pkg/sync/reconcile.go new file mode 100644 index 0000000000000..ae32dde56789a --- /dev/null +++ b/gitops-engine/pkg/sync/reconcile.go @@ -0,0 +1,117 @@ +package sync + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/types" + + hookutil "github.com/argoproj/gitops-engine/pkg/sync/hook" + "github.com/argoproj/gitops-engine/pkg/sync/ignore" + kubeutil "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/text" +) + +func splitHooks(target []*unstructured.Unstructured) ([]*unstructured.Unstructured, []*unstructured.Unstructured) { + targetObjs := make([]*unstructured.Unstructured, 0) + hooks := make([]*unstructured.Unstructured, 0) + for _, obj := range target { + if obj == nil || ignore.Ignore(obj) { + continue + } + if hookutil.IsHook(obj) { + hooks = append(hooks, obj) + } else { + targetObjs = append(targetObjs, obj) + } + } + return targetObjs, hooks +} + +// dedupLiveResources handles removes live resource duplicates with the same UID. Duplicates are created in a separate resource groups. +// E.g. apps/Deployment produces duplicate in extensions/Deployment, authorization.openshift.io/ClusterRole produces duplicate in rbac.authorization.k8s.io/ClusterRole etc. +// The method removes such duplicates unless it was defined in git ( exists in target resources list ). At least one duplicate stays. +// If non of duplicates are in git at random one stays +func dedupLiveResources(targetObjs []*unstructured.Unstructured, liveObjsByKey map[kubeutil.ResourceKey]*unstructured.Unstructured) { + targetObjByKey := make(map[kubeutil.ResourceKey]*unstructured.Unstructured) + for i := range targetObjs { + targetObjByKey[kubeutil.GetResourceKey(targetObjs[i])] = targetObjs[i] + } + liveObjsById := make(map[types.UID][]*unstructured.Unstructured) + for k := range liveObjsByKey { + obj := liveObjsByKey[k] + if obj != nil { + liveObjsById[obj.GetUID()] = append(liveObjsById[obj.GetUID()], obj) + } + } + for id := range liveObjsById { + objs := liveObjsById[id] + + if len(objs) > 1 { + duplicatesLeft := len(objs) + for i := range objs { + obj := objs[i] + resourceKey := kubeutil.GetResourceKey(obj) + if _, ok := targetObjByKey[resourceKey]; !ok { + delete(liveObjsByKey, resourceKey) + duplicatesLeft-- + if duplicatesLeft == 1 { + break + } + } + } + } + } +} + +type ReconciliationResult struct { + Live []*unstructured.Unstructured + Target []*unstructured.Unstructured + Hooks []*unstructured.Unstructured +} + +func Reconcile(targetObjs []*unstructured.Unstructured, liveObjByKey map[kubeutil.ResourceKey]*unstructured.Unstructured, namespace string, resInfo kubeutil.ResourceInfoProvider) ReconciliationResult { + targetObjs, hooks := splitHooks(targetObjs) + dedupLiveResources(targetObjs, liveObjByKey) + + managedLiveObj := make([]*unstructured.Unstructured, len(targetObjs)) + for i, obj := range targetObjs { + gvk := obj.GroupVersionKind() + + ns := text.FirstNonEmpty(obj.GetNamespace(), namespace) + + namespaced, err := resInfo.IsNamespaced(gvk.GroupKind()) + unknownScope := err != nil + + var keysToCheck []kubeutil.ResourceKey + // If we get an error, we don't know whether the resource is namespaced. So we need to check for both in the + // live objects. If we don't check for both, then we risk missing the object and deleting it. + if namespaced || unknownScope { + keysToCheck = append(keysToCheck, kubeutil.NewResourceKey(gvk.Group, gvk.Kind, ns, obj.GetName())) + } + if !namespaced || unknownScope { + keysToCheck = append(keysToCheck, kubeutil.NewResourceKey(gvk.Group, gvk.Kind, "", obj.GetName())) + } + + found := false + for _, key := range keysToCheck { + if liveObj, ok := liveObjByKey[key]; ok { + managedLiveObj[i] = liveObj + delete(liveObjByKey, key) + found = true + break + } + } + if !found { + managedLiveObj[i] = nil + } + } + + for _, obj := range liveObjByKey { + targetObjs = append(targetObjs, nil) + managedLiveObj = append(managedLiveObj, obj) + } + return ReconciliationResult{ + Target: targetObjs, + Hooks: hooks, + Live: managedLiveObj, + } +} diff --git a/gitops-engine/pkg/sync/reconcile_test.go b/gitops-engine/pkg/sync/reconcile_test.go new file mode 100644 index 0000000000000..f1f21db32b092 --- /dev/null +++ b/gitops-engine/pkg/sync/reconcile_test.go @@ -0,0 +1,52 @@ +package sync + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +type unknownResourceInfoProvider struct{} + +func (e *unknownResourceInfoProvider) IsNamespaced(_ schema.GroupKind) (bool, error) { + return false, errors.New("unknown") +} + +func TestReconcileWithUnknownDiscoveryDataForClusterScopedResources(t *testing.T) { + targetObjs := []*unstructured.Unstructured{ + { + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Namespace", + "metadata": map[string]any{ + "name": "my-namespace", + }, + }, + }, + } + + liveNS := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "v1", + "kind": "Namespace", + "metadata": map[string]any{ + "name": "my-namespace", + "uid": "c99ff56d-1921-495d-8512-d66cdfcb5740", + }, + }, + } + liveObjByKey := map[kube.ResourceKey]*unstructured.Unstructured{ + kube.NewResourceKey("", "Namespace", "", "my-namespace"): liveNS, + } + + result := Reconcile(targetObjs, liveObjByKey, "some-namespace", &unknownResourceInfoProvider{}) + require.Len(t, result.Target, 1) + require.Equal(t, result.Target[0], targetObjs[0]) + require.Len(t, result.Live, 1) + require.Equal(t, result.Live[0], liveNS) +} diff --git a/gitops-engine/pkg/sync/resource/annotations.go b/gitops-engine/pkg/sync/resource/annotations.go new file mode 100644 index 0000000000000..aa9c27cdcb8c1 --- /dev/null +++ b/gitops-engine/pkg/sync/resource/annotations.go @@ -0,0 +1,41 @@ +package resource + +import ( + "strings" +) + +// AnnotationGetter defines the operations required to inspect if a resource +// has annotations +type AnnotationGetter interface { + GetAnnotations() map[string]string +} + +// GetAnnotationCSVs will return the value of the annotation identified by +// the given key. If the annotation has comma separated values, the returned +// list will contain all deduped values. +func GetAnnotationCSVs(obj AnnotationGetter, key string) []string { + // may for de-duping + valuesToBool := make(map[string]bool) + for _, item := range strings.Split(obj.GetAnnotations()[key], ",") { + val := strings.TrimSpace(item) + if val != "" { + valuesToBool[val] = true + } + } + var values []string + for val := range valuesToBool { + values = append(values, val) + } + return values +} + +// HasAnnotationOption will return if the given obj has an annotation defined +// as the given key and has in its values, the occurrence of val. +func HasAnnotationOption(obj AnnotationGetter, key, val string) bool { + for _, item := range GetAnnotationCSVs(obj, key) { + if item == val { + return true + } + } + return false +} diff --git a/gitops-engine/pkg/sync/resource/annotations_test.go b/gitops-engine/pkg/sync/resource/annotations_test.go new file mode 100644 index 0000000000000..f024df192e4a9 --- /dev/null +++ b/gitops-engine/pkg/sync/resource/annotations_test.go @@ -0,0 +1,41 @@ +package resource + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestHasAnnotationOption(t *testing.T) { + type args struct { + obj *unstructured.Unstructured + key string + val string + } + tests := []struct { + name string + args args + wantVals []string + want bool + }{ + {"Nil", args{testingutils.NewPod(), "foo", "bar"}, nil, false}, + {"Empty", args{example(""), "foo", "bar"}, nil, false}, + {"Single", args{example("bar"), "foo", "bar"}, []string{"bar"}, true}, + {"DeDup", args{example("bar,bar"), "foo", "bar"}, []string{"bar"}, true}, + {"Double", args{example("bar,baz"), "foo", "baz"}, []string{"bar", "baz"}, true}, + {"Spaces", args{example("bar "), "foo", "bar"}, []string{"bar"}, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.ElementsMatch(t, tt.wantVals, GetAnnotationCSVs(tt.args.obj, tt.args.key)) + assert.Equal(t, tt.want, HasAnnotationOption(tt.args.obj, tt.args.key, tt.args.val)) + }) + } +} + +func example(val string) *unstructured.Unstructured { + return testingutils.Annotate(testingutils.NewPod(), "foo", val) +} diff --git a/gitops-engine/pkg/sync/sync_context.go b/gitops-engine/pkg/sync/sync_context.go new file mode 100644 index 0000000000000..675e1d04e68e8 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_context.go @@ -0,0 +1,1626 @@ +package sync + +import ( + "context" + "encoding/json" + "fmt" + "sort" + "strings" + "sync" + "time" + + "github.com/go-logr/logr" + corev1 "k8s.io/api/core/v1" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/wait" + "k8s.io/client-go/discovery" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" + "k8s.io/client-go/util/retry" + "k8s.io/klog/v2/textlogger" + cmdutil "k8s.io/kubectl/pkg/cmd/util" + "k8s.io/kubectl/pkg/util/openapi" + + "github.com/argoproj/gitops-engine/pkg/diff" + "github.com/argoproj/gitops-engine/pkg/health" + "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/sync/hook" + resourceutil "github.com/argoproj/gitops-engine/pkg/sync/resource" + kubeutil "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +type reconciledResource struct { + Target *unstructured.Unstructured + Live *unstructured.Unstructured +} + +func (r *reconciledResource) key() kubeutil.ResourceKey { + if r.Live != nil { + return kubeutil.GetResourceKey(r.Live) + } + return kubeutil.GetResourceKey(r.Target) +} + +// SyncContext defines an interface that allows to execute sync operation step or terminate it. +type SyncContext interface { + // Terminate terminates sync operation. The method is asynchronous: it starts deletion is related K8S resources + // such as in-flight resource hooks, updates operation status, and exists without waiting for resource completion. + Terminate() + // Executes next synchronization step and updates operation status. + Sync() + // Returns current sync operation state and information about resources synchronized so far. + GetState() (common.OperationPhase, string, []common.ResourceSyncResult) +} + +// SyncOpt is a callback that update sync operation settings +type SyncOpt func(ctx *syncContext) + +// WithPrunePropagationPolicy sets specified permission validator +func WithPrunePropagationPolicy(policy *metav1.DeletionPropagation) SyncOpt { + return func(ctx *syncContext) { + ctx.prunePropagationPolicy = policy + } +} + +// WithPermissionValidator sets specified permission validator +func WithPermissionValidator(validator common.PermissionValidator) SyncOpt { + return func(ctx *syncContext) { + ctx.permissionValidator = validator + } +} + +// WithHealthOverride sets specified health override +func WithHealthOverride(override health.HealthOverride) SyncOpt { + return func(ctx *syncContext) { + ctx.healthOverride = override + } +} + +// WithInitialState sets sync operation initial state +func WithInitialState(phase common.OperationPhase, message string, results []common.ResourceSyncResult, startedAt metav1.Time) SyncOpt { + return func(ctx *syncContext) { + ctx.phase = phase + ctx.message = message + ctx.syncRes = map[string]common.ResourceSyncResult{} + ctx.startedAt = startedAt.Time + for i := range results { + ctx.syncRes[resourceResultKey(results[i].ResourceKey, results[i].SyncPhase)] = results[i] + } + } +} + +// WithResourcesFilter sets sync operation resources filter +func WithResourcesFilter(resourcesFilter func(key kubeutil.ResourceKey, target *unstructured.Unstructured, live *unstructured.Unstructured) bool) SyncOpt { + return func(ctx *syncContext) { + ctx.resourcesFilter = resourcesFilter + } +} + +// WithSkipHooks specifies if hooks should be enabled or not +func WithSkipHooks(skipHooks bool) SyncOpt { + return func(ctx *syncContext) { + ctx.skipHooks = skipHooks + } +} + +// WithPrune specifies if resource pruning enabled +func WithPrune(prune bool) SyncOpt { + return func(ctx *syncContext) { + ctx.prune = prune + } +} + +// WithPruneConfirmed specifies if prune is confirmed for resources that require confirmation +func WithPruneConfirmed(confirmed bool) SyncOpt { + return func(ctx *syncContext) { + ctx.pruneConfirmed = confirmed + } +} + +// WithOperationSettings allows to set sync operation settings +func WithOperationSettings(dryRun bool, prune bool, force bool, skipHooks bool) SyncOpt { + return func(ctx *syncContext) { + ctx.prune = prune + ctx.skipHooks = skipHooks + ctx.dryRun = dryRun + ctx.force = force + } +} + +// WithManifestValidation enables or disables manifest validation +func WithManifestValidation(enabled bool) SyncOpt { + return func(ctx *syncContext) { + ctx.validate = enabled + } +} + +// WithPruneLast enables or disables pruneLast +func WithPruneLast(enabled bool) SyncOpt { + return func(ctx *syncContext) { + ctx.pruneLast = enabled + } +} + +// WithResourceModificationChecker sets resource modification result +func WithResourceModificationChecker(enabled bool, diffResults *diff.DiffResultList) SyncOpt { + return func(ctx *syncContext) { + ctx.applyOutOfSyncOnly = enabled + if enabled { + ctx.modificationResult = groupDiffResults(diffResults) + } else { + ctx.modificationResult = nil + } + } +} + +// WithNamespaceModifier will create a namespace with the metadata passed in the `*unstructured.Unstructured` argument +// of the `namespaceModifier` function, in the case it returns `true`. If the namespace already exists, the metadata +// will overwrite what is already present if `namespaceModifier` returns `true`. If `namespaceModifier` returns `false`, +// this will be a no-op. +func WithNamespaceModifier(namespaceModifier func(*unstructured.Unstructured, *unstructured.Unstructured) (bool, error)) SyncOpt { + return func(ctx *syncContext) { + ctx.syncNamespace = namespaceModifier + } +} + +// WithLogr sets the logger to use. +func WithLogr(log logr.Logger) SyncOpt { + return func(ctx *syncContext) { + ctx.log = log + } +} + +// WithSyncWaveHook sets a callback that is invoked after application of every wave +func WithSyncWaveHook(syncWaveHook common.SyncWaveHook) SyncOpt { + return func(ctx *syncContext) { + ctx.syncWaveHook = syncWaveHook + } +} + +func WithReplace(replace bool) SyncOpt { + return func(ctx *syncContext) { + ctx.replace = replace + } +} + +func WithSkipDryRunOnMissingResource(skipDryRunOnMissingResource bool) SyncOpt { + return func(ctx *syncContext) { + ctx.skipDryRunOnMissingResource = skipDryRunOnMissingResource + } +} + +func WithServerSideApply(serverSideApply bool) SyncOpt { + return func(ctx *syncContext) { + ctx.serverSideApply = serverSideApply + } +} + +func WithServerSideApplyManager(manager string) SyncOpt { + return func(ctx *syncContext) { + ctx.serverSideApplyManager = manager + } +} + +// WithClientSideApplyMigration configures client-side apply migration for server-side apply. +// When enabled, fields managed by the specified manager will be migrated to server-side apply. +// Defaults to enabled=true with manager="kubectl-client-side-apply" if not configured. +func WithClientSideApplyMigration(enabled bool, manager string) SyncOpt { + return func(ctx *syncContext) { + ctx.enableClientSideApplyMigration = enabled + if enabled && manager != "" { + ctx.clientSideApplyMigrationManager = manager + } + } +} + +// NewSyncContext creates new instance of a SyncContext +func NewSyncContext( + revision string, + reconciliationResult ReconciliationResult, + restConfig *rest.Config, + rawConfig *rest.Config, + kubectl kubeutil.Kubectl, + namespace string, + openAPISchema openapi.Resources, + opts ...SyncOpt, +) (SyncContext, func(), error) { + dynamicIf, err := dynamic.NewForConfig(restConfig) + if err != nil { + return nil, nil, fmt.Errorf("failed to create dynamic client: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(restConfig) + if err != nil { + return nil, nil, fmt.Errorf("failed to create discovery client: %w", err) + } + extensionsclientset, err := clientset.NewForConfig(restConfig) + if err != nil { + return nil, nil, fmt.Errorf("failed to create extensions client: %w", err) + } + resourceOps, cleanup, err := kubectl.ManageResources(rawConfig, openAPISchema) + if err != nil { + return nil, nil, fmt.Errorf("failed to manage resources: %w", err) + } + ctx := &syncContext{ + revision: revision, + resources: groupResources(reconciliationResult), + hooks: reconciliationResult.Hooks, + config: restConfig, + rawConfig: rawConfig, + dynamicIf: dynamicIf, + disco: disco, + extensionsclientset: extensionsclientset, + kubectl: kubectl, + resourceOps: resourceOps, + namespace: namespace, + log: textlogger.NewLogger(textlogger.NewConfig()), + validate: true, + startedAt: time.Now(), + syncRes: map[string]common.ResourceSyncResult{}, + clientSideApplyMigrationManager: common.DefaultClientSideApplyMigrationManager, + enableClientSideApplyMigration: true, + permissionValidator: func(_ *unstructured.Unstructured, _ *metav1.APIResource) error { + return nil + }, + } + for _, opt := range opts { + opt(ctx) + } + return ctx, cleanup, nil +} + +func groupResources(reconciliationResult ReconciliationResult) map[kubeutil.ResourceKey]reconciledResource { + resources := make(map[kubeutil.ResourceKey]reconciledResource) + for i := 0; i < len(reconciliationResult.Target); i++ { + res := reconciledResource{ + Target: reconciliationResult.Target[i], + Live: reconciliationResult.Live[i], + } + + var obj *unstructured.Unstructured + if res.Live != nil { + obj = res.Live + } else { + obj = res.Target + } + resources[kubeutil.GetResourceKey(obj)] = res + } + return resources +} + +// generates a map of resource and its modification result based on diffResultList +func groupDiffResults(diffResultList *diff.DiffResultList) map[kubeutil.ResourceKey]bool { + modifiedResources := make(map[kubeutil.ResourceKey]bool) + for _, res := range diffResultList.Diffs { + var obj unstructured.Unstructured + var err error + if string(res.NormalizedLive) != "null" { + err = json.Unmarshal(res.NormalizedLive, &obj) + } else { + err = json.Unmarshal(res.PredictedLive, &obj) + } + if err != nil { + continue + } + modifiedResources[kubeutil.GetResourceKey(&obj)] = res.Modified + } + return modifiedResources +} + +const ( + crdReadinessTimeout = time.Duration(3) * time.Second +) + +// getOperationPhase returns a health status from a _live_ unstructured object +func (sc *syncContext) getOperationPhase(obj *unstructured.Unstructured) (common.OperationPhase, string, error) { + phase := common.OperationSucceeded + message := obj.GetName() + " created" + + resHealth, err := health.GetResourceHealth(obj, sc.healthOverride) + if err != nil { + return "", "", fmt.Errorf("failed to get resource health: %w", err) + } + if resHealth != nil { + switch resHealth.Status { + case health.HealthStatusUnknown, health.HealthStatusDegraded: + phase = common.OperationFailed + message = resHealth.Message + case health.HealthStatusProgressing, health.HealthStatusSuspended: + phase = common.OperationRunning + message = resHealth.Message + case health.HealthStatusHealthy: + phase = common.OperationSucceeded + message = resHealth.Message + } + } + return phase, message, nil +} + +type syncContext struct { + healthOverride health.HealthOverride + permissionValidator common.PermissionValidator + resources map[kubeutil.ResourceKey]reconciledResource + hooks []*unstructured.Unstructured + config *rest.Config + rawConfig *rest.Config + dynamicIf dynamic.Interface + disco discovery.DiscoveryInterface + extensionsclientset *clientset.Clientset + kubectl kubeutil.Kubectl + resourceOps kubeutil.ResourceOperations + namespace string + + dryRun bool + skipDryRunOnMissingResource bool + force bool + validate bool + skipHooks bool + resourcesFilter func(key kubeutil.ResourceKey, target *unstructured.Unstructured, live *unstructured.Unstructured) bool + prune bool + replace bool + serverSideApply bool + serverSideApplyManager string + pruneLast bool + prunePropagationPolicy *metav1.DeletionPropagation + pruneConfirmed bool + clientSideApplyMigrationManager string + enableClientSideApplyMigration bool + + syncRes map[string]common.ResourceSyncResult + startedAt time.Time + revision string + phase common.OperationPhase + message string + + log logr.Logger + // lock to protect concurrent updates of the result list + lock sync.Mutex + + // syncNamespace is a function that will determine if the managed + // namespace should be synced + syncNamespace func(*unstructured.Unstructured, *unstructured.Unstructured) (bool, error) + + syncWaveHook common.SyncWaveHook + + applyOutOfSyncOnly bool + // stores whether the resource is modified or not + modificationResult map[kubeutil.ResourceKey]bool +} + +func (sc *syncContext) setRunningPhase(tasks []*syncTask, isPendingDeletion bool) { + if len(tasks) > 0 { + firstTask := tasks[0] + waitingFor := "completion of hook" + andMore := "hooks" + if !firstTask.isHook() { + waitingFor = "healthy state of" + andMore = "resources" + } + if isPendingDeletion { + waitingFor = "deletion of" + } + message := fmt.Sprintf("waiting for %s %s/%s/%s", + waitingFor, firstTask.group(), firstTask.kind(), firstTask.name()) + if moreTasks := len(tasks) - 1; moreTasks > 0 { + message = fmt.Sprintf("%s and %d more %s", message, moreTasks, andMore) + } + sc.setOperationPhase(common.OperationRunning, message) + } +} + +// sync has performs the actual apply or hook based sync +func (sc *syncContext) Sync() { + sc.log.WithValues("skipHooks", sc.skipHooks, "started", sc.started()).Info("Syncing") + tasks, ok := sc.getSyncTasks() + if !ok { + sc.setOperationPhase(common.OperationFailed, "one or more synchronization tasks are not valid") + return + } + + if sc.started() { + sc.log.WithValues("tasks", tasks).Info("Tasks") + } else { + // Perform a `kubectl apply --dry-run` against all the manifests. This will detect most (but + // not all) validation issues with the user's manifests (e.g. will detect syntax issues, but + // will not not detect if they are mutating immutable fields). If anything fails, we will refuse + // to perform the sync. we only wish to do this once per operation, performing additional dry-runs + // is harmless, but redundant. The indicator we use to detect if we have already performed + // the dry-run for this operation, is if the resource or hook list is empty. + dryRunTasks := tasks + + // Before doing any validation, we have to create the application namespace if it does not exist. + // The validation is expected to fail in multiple scenarios if a namespace does not exist. + if nsCreateTask := sc.getNamespaceCreationTask(dryRunTasks); nsCreateTask != nil { + nsSyncTasks := syncTasks{nsCreateTask} + // No need to perform a dry-run on the namespace creation, because if it fails we stop anyway + sc.log.WithValues("task", nsCreateTask).Info("Creating namespace") + if sc.runTasks(nsSyncTasks, false) == failed { + sc.setOperationFailed(syncTasks{}, nsSyncTasks, "the namespace failed to apply") + return + } + + // The namespace was created, we can remove this task from the dry-run + dryRunTasks = tasks.Filter(func(t *syncTask) bool { return t != nsCreateTask }) + } + + if sc.applyOutOfSyncOnly { + dryRunTasks = sc.filterOutOfSyncTasks(dryRunTasks) + } + + sc.log.WithValues("tasks", dryRunTasks).Info("Tasks (dry-run)") + if sc.runTasks(dryRunTasks, true) == failed { + sc.setOperationPhase(common.OperationFailed, "one or more objects failed to apply (dry run)") + return + } + } + + // update status of any tasks that are running, note that this must exclude pruning tasks + for _, task := range tasks.Filter(func(t *syncTask) bool { + // just occasionally, you can be running yet not have a live resource + return t.running() && t.liveObj != nil + }) { + if task.isHook() { + // update the hook's result + operationState, message, err := sc.getOperationPhase(task.liveObj) + if err != nil { + sc.setResourceResult(task, "", common.OperationError, fmt.Sprintf("failed to get resource health: %v", err)) + } else { + sc.setResourceResult(task, "", operationState, message) + } + } else { + // this must be calculated on the live object + healthStatus, err := health.GetResourceHealth(task.liveObj, sc.healthOverride) + if err == nil { + sc.log.WithValues("task", task, "healthStatus", healthStatus).V(1).Info("attempting to update health of running task") + if healthStatus == nil { + // some objects (e.g. secret) do not have health, and they automatically success + sc.setResourceResult(task, task.syncStatus, common.OperationSucceeded, task.message) + } else { + switch healthStatus.Status { + case health.HealthStatusHealthy: + sc.setResourceResult(task, task.syncStatus, common.OperationSucceeded, healthStatus.Message) + case health.HealthStatusDegraded: + sc.setResourceResult(task, task.syncStatus, common.OperationFailed, healthStatus.Message) + } + } + } + } + } + + // if (a) we are multi-step and we have any running tasks, + // or (b) there are any running hooks, + // then wait... + multiStep := tasks.multiStep() + runningTasks := tasks.Filter(func(t *syncTask) bool { return (multiStep || t.isHook()) && t.running() }) + if runningTasks.Len() > 0 { + sc.setRunningPhase(runningTasks, false) + return + } + + // if pruned tasks pending deletion, then wait... + prunedTasksPendingDelete := tasks.Filter(func(t *syncTask) bool { + if t.pruned() && t.liveObj != nil { + return t.liveObj.GetDeletionTimestamp() != nil + } + return false + }) + if prunedTasksPendingDelete.Len() > 0 { + sc.setRunningPhase(prunedTasksPendingDelete, true) + return + } + + hooksCompleted := tasks.Filter(func(task *syncTask) bool { + return task.isHook() && task.completed() + }) + for _, task := range hooksCompleted { + if err := sc.removeHookFinalizer(task); err != nil { + sc.setResourceResult(task, task.syncStatus, common.OperationError, fmt.Sprintf("Failed to remove hook finalizer: %v", err)) + } + } + + // collect all completed hooks which have appropriate delete policy + hooksPendingDeletionSuccessful := tasks.Filter(func(task *syncTask) bool { + return task.isHook() && task.liveObj != nil && !task.running() && task.deleteOnPhaseSuccessful() + }) + + hooksPendingDeletionFailed := tasks.Filter(func(task *syncTask) bool { + return task.isHook() && task.liveObj != nil && !task.running() && task.deleteOnPhaseFailed() + }) + + // syncFailTasks only run during failure, so separate them from regular tasks + syncFailTasks, tasks := tasks.Split(func(t *syncTask) bool { return t.phase == common.SyncPhaseSyncFail }) + + syncFailedTasks, _ := tasks.Split(func(t *syncTask) bool { return t.syncStatus == common.ResultCodeSyncFailed }) + + // if there are any completed but unsuccessful tasks, sync is a failure. + if tasks.Any(func(t *syncTask) bool { return t.completed() && !t.successful() }) { + sc.deleteHooks(hooksPendingDeletionFailed) + sc.setOperationFailed(syncFailTasks, syncFailedTasks, "one or more synchronization tasks completed unsuccessfully") + return + } + + sc.log.WithValues("tasks", tasks).V(1).Info("Filtering out non-pending tasks") + // remove tasks that are completed, we can assume that there are no running tasks + tasks = tasks.Filter(func(t *syncTask) bool { return t.pending() }) + + if sc.applyOutOfSyncOnly { + tasks = sc.filterOutOfSyncTasks(tasks) + } + + // If no sync tasks were generated (e.g., in case all application manifests have been removed), + // the sync operation is successful. + if len(tasks) == 0 { + // delete all completed hooks which have appropriate delete policy + sc.deleteHooks(hooksPendingDeletionSuccessful) + sc.setOperationPhase(common.OperationSucceeded, "successfully synced (no more tasks)") + return + } + + // remove any tasks not in this wave + phase := tasks.phase() + wave := tasks.wave() + finalWave := phase == tasks.lastPhase() && wave == tasks.lastWave() + + // if it is the last phase/wave and the only remaining tasks are non-hooks, the we are successful + // EVEN if those objects subsequently degraded + // This handles the common case where neither hooks or waves are used and a sync equates to simply an (asynchronous) kubectl apply of manifests, which succeeds immediately. + remainingTasks := tasks.Filter(func(t *syncTask) bool { return t.phase != phase || wave != t.wave() || t.isHook() }) + + sc.log.WithValues("phase", phase, "wave", wave, "tasks", tasks, "syncFailTasks", syncFailTasks).V(1).Info("Filtering tasks in correct phase and wave") + tasks = tasks.Filter(func(t *syncTask) bool { return t.phase == phase && t.wave() == wave }) + + sc.setOperationPhase(common.OperationRunning, "one or more tasks are running") + + sc.log.WithValues("tasks", tasks).V(1).Info("Wet-run") + runState := sc.runTasks(tasks, false) + + if sc.syncWaveHook != nil && runState != failed { + err := sc.syncWaveHook(phase, wave, finalWave) + if err != nil { + sc.deleteHooks(hooksPendingDeletionFailed) + sc.setOperationPhase(common.OperationFailed, fmt.Sprintf("SyncWaveHook failed: %v", err)) + sc.log.Error(err, "SyncWaveHook failed") + return + } + } + + switch runState { + case failed: + syncFailedTasks, _ := tasks.Split(func(t *syncTask) bool { return t.syncStatus == common.ResultCodeSyncFailed }) + sc.deleteHooks(hooksPendingDeletionFailed) + sc.setOperationFailed(syncFailTasks, syncFailedTasks, "one or more objects failed to apply") + case successful: + if remainingTasks.Len() == 0 { + // delete all completed hooks which have appropriate delete policy + sc.deleteHooks(hooksPendingDeletionSuccessful) + sc.setOperationPhase(common.OperationSucceeded, "successfully synced (all tasks run)") + } else { + sc.setRunningPhase(remainingTasks, false) + } + default: + sc.setRunningPhase(tasks.Filter(func(task *syncTask) bool { + return task.deleteOnPhaseCompletion() + }), true) + } +} + +// filter out out-of-sync tasks +func (sc *syncContext) filterOutOfSyncTasks(tasks syncTasks) syncTasks { + return tasks.Filter(func(t *syncTask) bool { + if t.isHook() { + return true + } + + if modified, ok := sc.modificationResult[t.resourceKey()]; !modified && ok && t.targetObj != nil && t.liveObj != nil { + sc.log.WithValues("resource key", t.resourceKey()).V(1).Info("Skipping as resource was not modified") + return false + } + return true + }) +} + +// getNamespaceCreationTask returns a task that will create the current namespace +// or nil if the syncTasks does not contain one +func (sc *syncContext) getNamespaceCreationTask(tasks syncTasks) *syncTask { + creationTasks := tasks.Filter(func(task *syncTask) bool { + return task.liveObj == nil && isNamespaceWithName(task.targetObj, sc.namespace) + }) + if len(creationTasks) > 0 { + return creationTasks[0] + } + return nil +} + +func (sc *syncContext) removeHookFinalizer(task *syncTask) error { + if task.liveObj == nil { + return nil + } + removeFinalizerMutation := func(obj *unstructured.Unstructured) bool { + finalizers := obj.GetFinalizers() + for i, finalizer := range finalizers { + if finalizer == hook.HookFinalizer { + obj.SetFinalizers(append(finalizers[:i], finalizers[i+1:]...)) + return true + } + } + return false + } + + // The cached live object may be stale in the controller cache, and the actual object may have been updated in the meantime, + // and Kubernetes API will return a conflict error on the Update call. + // In that case, we need to get the latest version of the object and retry the update. + //nolint:wrapcheck // wrap inside the retried function instead + return retry.RetryOnConflict(retry.DefaultRetry, func() error { + mutated := removeFinalizerMutation(task.liveObj) + if !mutated { + return nil + } + + updateErr := sc.updateResource(task) + if apierrors.IsConflict(updateErr) { + sc.log.WithValues("task", task).V(1).Info("Retrying hook finalizer removal due to conflict on update") + liveObj, err := sc.getResource(task) + if apierrors.IsNotFound(err) { + sc.log.WithValues("task", task).V(1).Info("Resource is already deleted") + return nil + } else if err != nil { + return fmt.Errorf("failed to get resource: %w", err) + } + task.liveObj = liveObj + } else if apierrors.IsNotFound(updateErr) { + // If the resource is already deleted, it is a no-op + sc.log.WithValues("task", task).V(1).Info("Resource is already deleted") + return nil + } + if updateErr != nil { + return fmt.Errorf("failed to update resource: %w", updateErr) + } + return nil + }) +} + +func (sc *syncContext) getResource(task *syncTask) (*unstructured.Unstructured, error) { + sc.log.WithValues("task", task).V(1).Info("Getting resource") + resIf, err := sc.getResourceIf(task, "get") + if err != nil { + return nil, err + } + liveObj, err := resIf.Get(context.TODO(), task.name(), metav1.GetOptions{}) + if err != nil { + return nil, fmt.Errorf("failed to get resource: %w", err) + } + return liveObj, nil +} + +func (sc *syncContext) updateResource(task *syncTask) error { + sc.log.WithValues("task", task).V(1).Info("Updating resource") + resIf, err := sc.getResourceIf(task, "update") + if err != nil { + return err + } + _, err = resIf.Update(context.TODO(), task.liveObj, metav1.UpdateOptions{}) + if err != nil { + return fmt.Errorf("failed to update resource: %w", err) + } + return nil +} + +func (sc *syncContext) deleteHooks(hooksPendingDeletion syncTasks) { + for _, task := range hooksPendingDeletion { + err := sc.deleteResource(task) + if err != nil && !apierrors.IsNotFound(err) { + sc.setResourceResult(task, "", common.OperationError, fmt.Sprintf("failed to delete resource: %v", err)) + } + } +} + +func (sc *syncContext) GetState() (common.OperationPhase, string, []common.ResourceSyncResult) { + var resourceRes []common.ResourceSyncResult + for _, v := range sc.syncRes { + resourceRes = append(resourceRes, v) + } + sort.Slice(resourceRes, func(i, j int) bool { + return resourceRes[i].Order < resourceRes[j].Order + }) + return sc.phase, sc.message, resourceRes +} + +func (sc *syncContext) setOperationFailed(syncFailTasks, syncFailedTasks syncTasks, message string) { + errorMessageFactory := func(tasks syncTasks, message string) string { + messages := tasks.Map(func(task *syncTask) string { + return task.message + }) + if len(messages) > 0 { + return fmt.Sprintf("%s, reason: %s", message, strings.Join(messages, ",")) + } + return message + } + + errorMessage := errorMessageFactory(syncFailedTasks, message) + + if len(syncFailTasks) > 0 { + // if all the failure hooks are completed, don't run them again, and mark the sync as failed + if syncFailTasks.All(func(task *syncTask) bool { return task.completed() }) { + sc.setOperationPhase(common.OperationFailed, errorMessage) + return + } + // otherwise, we need to start the failure hooks, and then return without setting + // the phase, so we make sure we have at least one more sync + sc.log.WithValues("syncFailTasks", syncFailTasks).V(1).Info("Running sync fail tasks") + if sc.runTasks(syncFailTasks, false) == failed { + failedSyncFailTasks := syncFailTasks.Filter(func(t *syncTask) bool { return t.syncStatus == common.ResultCodeSyncFailed }) + syncFailTasksMessage := errorMessageFactory(failedSyncFailTasks, "one or more SyncFail hooks failed") + sc.setOperationPhase(common.OperationFailed, fmt.Sprintf("%s\n%s", errorMessage, syncFailTasksMessage)) + } + } else { + sc.setOperationPhase(common.OperationFailed, errorMessage) + } +} + +func (sc *syncContext) started() bool { + return len(sc.syncRes) > 0 +} + +func (sc *syncContext) containsResource(resource reconciledResource) bool { + return sc.resourcesFilter == nil || sc.resourcesFilter(resource.key(), resource.Target, resource.Live) +} + +// generates the list of sync tasks we will be performing during this sync. +func (sc *syncContext) getSyncTasks() (_ syncTasks, successful bool) { + resourceTasks := syncTasks{} + successful = true + + for k, resource := range sc.resources { + if !sc.containsResource(resource) { + sc.log.WithValues("group", k.Group, "kind", k.Kind, "name", k.Name).V(1).Info("Skipping") + continue + } + + obj := obj(resource.Target, resource.Live) + + // this creates garbage tasks + if hook.IsHook(obj) { + sc.log.WithValues("group", obj.GroupVersionKind().Group, "kind", obj.GetKind(), "namespace", obj.GetNamespace(), "name", obj.GetName()).V(1).Info("Skipping hook") + continue + } + + for _, phase := range syncPhases(obj) { + resourceTasks = append(resourceTasks, &syncTask{phase: phase, targetObj: resource.Target, liveObj: resource.Live}) + } + } + + sc.log.WithValues("resourceTasks", resourceTasks).V(1).Info("Tasks from managed resources") + + hookTasks := syncTasks{} + if !sc.skipHooks { + for _, obj := range sc.hooks { + for _, phase := range syncPhases(obj) { + // Hook resources names are deterministic, whether they are defined by the user (metadata.name), + // or formulated at the time of the operation (metadata.generateName). If user specifies + // metadata.generateName, then we will generate a formulated metadata.name before submission. + targetObj := obj.DeepCopy() + if targetObj.GetName() == "" { + var syncRevision string + if len(sc.revision) >= 8 { + syncRevision = sc.revision[0:7] + } else { + syncRevision = sc.revision + } + postfix := strings.ToLower(fmt.Sprintf("%s-%s-%d", syncRevision, phase, sc.startedAt.UTC().Unix())) + generateName := obj.GetGenerateName() + targetObj.SetName(fmt.Sprintf("%s%s", generateName, postfix)) + } + if !hook.HasHookFinalizer(targetObj) { + targetObj.SetFinalizers(append(targetObj.GetFinalizers(), hook.HookFinalizer)) + } + hookTasks = append(hookTasks, &syncTask{phase: phase, targetObj: targetObj}) + } + } + } + + sc.log.WithValues("hookTasks", hookTasks).V(1).Info("tasks from hooks") + + tasks := resourceTasks + tasks = append(tasks, hookTasks...) + + // enrich target objects with the namespace + for _, task := range tasks { + if task.targetObj == nil { + continue + } + + if task.targetObj.GetNamespace() == "" { + // If target object's namespace is empty, we set namespace in the object. We do + // this even though it might be a cluster-scoped resource. This prevents any + // possibility of the resource from unintentionally becoming created in the + // namespace during the `kubectl apply` + task.targetObj = task.targetObj.DeepCopy() + task.targetObj.SetNamespace(sc.namespace) + } + } + + if sc.syncNamespace != nil && sc.namespace != "" { + tasks = sc.autoCreateNamespace(tasks) + } + + // enrich task with live obj + for _, task := range tasks { + if task.targetObj == nil || task.liveObj != nil { + continue + } + task.liveObj = sc.liveObj(task.targetObj) + } + + isRetryable := apierrors.IsUnauthorized + + serverResCache := make(map[schema.GroupVersionKind]*metav1.APIResource) + + // check permissions + for _, task := range tasks { + var serverRes *metav1.APIResource + var err error + + if val, ok := serverResCache[task.groupVersionKind()]; ok { + serverRes = val + err = nil + } else { + err = retry.OnError(retry.DefaultRetry, isRetryable, func() error { + serverRes, err = kubeutil.ServerResourceForGroupVersionKind(sc.disco, task.groupVersionKind(), "get") + //nolint:wrapcheck // complicated function, not wrapping to avoid failure of error type checks + return err + }) + if serverRes != nil { + serverResCache[task.groupVersionKind()] = serverRes + } + } + + shouldSkipDryRunOnMissingResource := func() bool { + // skip dry run on missing resource error for all application resources + if sc.skipDryRunOnMissingResource { + return true + } + return (task.targetObj != nil && resourceutil.HasAnnotationOption(task.targetObj, common.AnnotationSyncOptions, common.SyncOptionSkipDryRunOnMissingResource)) || + sc.hasCRDOfGroupKind(task.group(), task.kind()) + } + + if err != nil { + switch { + case apierrors.IsNotFound(err) && shouldSkipDryRunOnMissingResource(): + // Special case for custom resources: if CRD is not yet known by the K8s API server, + // and the CRD is part of this sync or the resource is annotated with SkipDryRunOnMissingResource=true, + // then skip verification during `kubectl apply --dry-run` since we expect the CRD + // to be created during app synchronization. + sc.log.WithValues("task", task).V(1).Info("Skip dry-run for custom resource") + task.skipDryRun = true + default: + sc.setResourceResult(task, common.ResultCodeSyncFailed, "", err.Error()) + successful = false + } + } else { + if err := sc.permissionValidator(task.obj(), serverRes); err != nil { + sc.setResourceResult(task, common.ResultCodeSyncFailed, "", err.Error()) + successful = false + } + } + } + + // for prune tasks, modify the waves for proper cleanup i.e reverse of sync wave (creation order) + pruneTasks := make(map[int][]*syncTask) + for _, task := range tasks { + if task.isPrune() { + pruneTasks[task.wave()] = append(pruneTasks[task.wave()], task) + } + } + + var uniquePruneWaves []int + for k := range pruneTasks { + uniquePruneWaves = append(uniquePruneWaves, k) + } + sort.Ints(uniquePruneWaves) + + // reorder waves for pruning tasks using symmetric swap on prune waves + n := len(uniquePruneWaves) + for i := 0; i < n/2; i++ { + // waves to swap + startWave := uniquePruneWaves[i] + endWave := uniquePruneWaves[n-1-i] + + for _, task := range pruneTasks[startWave] { + task.waveOverride = &endWave + } + + for _, task := range pruneTasks[endWave] { + task.waveOverride = &startWave + } + } + + // for pruneLast tasks, modify the wave to sync phase last wave of tasks + 1 + // to ensure proper cleanup, syncPhaseLastWave should also consider prune tasks to determine last wave + syncPhaseLastWave := 0 + for _, task := range tasks { + if task.phase == common.SyncPhaseSync { + if task.wave() > syncPhaseLastWave { + syncPhaseLastWave = task.wave() + } + } + } + syncPhaseLastWave = syncPhaseLastWave + 1 + + for _, task := range tasks { + if task.isPrune() && + (sc.pruneLast || resourceutil.HasAnnotationOption(task.liveObj, common.AnnotationSyncOptions, common.SyncOptionPruneLast)) { + task.waveOverride = &syncPhaseLastWave + } + } + + tasks.Sort() + + // finally enrich tasks with the result + for _, task := range tasks { + result, ok := sc.syncRes[task.resultKey()] + if ok { + task.syncStatus = result.Status + task.operationState = result.HookPhase + task.message = result.Message + } + } + + return tasks, successful +} + +func (sc *syncContext) autoCreateNamespace(tasks syncTasks) syncTasks { + isNamespaceCreationNeeded := true + + var allObjs []*unstructured.Unstructured + copy(allObjs, sc.hooks) + for _, res := range sc.resources { + allObjs = append(allObjs, res.Target) + } + + for _, res := range allObjs { + if isNamespaceWithName(res, sc.namespace) { + isNamespaceCreationNeeded = false + break + } + } + + if isNamespaceCreationNeeded { + nsSpec := &corev1.Namespace{TypeMeta: metav1.TypeMeta{APIVersion: "v1", Kind: kubeutil.NamespaceKind}, ObjectMeta: metav1.ObjectMeta{Name: sc.namespace}} + managedNs, err := kubeutil.ToUnstructured(nsSpec) + if err == nil { + liveObj, err := sc.kubectl.GetResource(context.TODO(), sc.config, managedNs.GroupVersionKind(), managedNs.GetName(), metav1.NamespaceNone) + switch { + case err == nil: + nsTask := &syncTask{phase: common.SyncPhasePreSync, targetObj: managedNs, liveObj: liveObj} + _, ok := sc.syncRes[nsTask.resultKey()] + if !ok && liveObj != nil { + sc.log.WithValues("namespace", sc.namespace).Info("Namespace already exists") + } + tasks = sc.appendNsTask(tasks, nsTask, managedNs, liveObj) + + case apierrors.IsNotFound(err): + tasks = sc.appendNsTask(tasks, &syncTask{phase: common.SyncPhasePreSync, targetObj: managedNs, liveObj: nil}, managedNs, nil) + default: + tasks = sc.appendFailedNsTask(tasks, managedNs, fmt.Errorf("namespace auto creation failed: %w", err)) + } + } else { + sc.setOperationPhase(common.OperationFailed, fmt.Sprintf("namespace auto creation failed: %s", err)) + } + } + return tasks +} + +func (sc *syncContext) appendNsTask(tasks syncTasks, preTask *syncTask, managedNs, liveNs *unstructured.Unstructured) syncTasks { + modified, err := sc.syncNamespace(managedNs, liveNs) + if err != nil { + tasks = sc.appendFailedNsTask(tasks, managedNs, fmt.Errorf("namespaceModifier error: %w", err)) + } else if modified { + tasks = append(tasks, preTask) + } + + return tasks +} + +func (sc *syncContext) appendFailedNsTask(tasks syncTasks, unstructuredObj *unstructured.Unstructured, err error) syncTasks { + task := &syncTask{phase: common.SyncPhasePreSync, targetObj: unstructuredObj} + sc.setResourceResult(task, common.ResultCodeSyncFailed, common.OperationError, err.Error()) + tasks = append(tasks, task) + return tasks +} + +func isNamespaceWithName(res *unstructured.Unstructured, ns string) bool { + return isNamespaceKind(res) && + res.GetName() == ns +} + +func isNamespaceKind(res *unstructured.Unstructured) bool { + return res != nil && + res.GetObjectKind().GroupVersionKind().Group == "" && + res.GetKind() == kubeutil.NamespaceKind +} + +func obj(a, b *unstructured.Unstructured) *unstructured.Unstructured { + if a != nil { + return a + } + return b +} + +func (sc *syncContext) liveObj(obj *unstructured.Unstructured) *unstructured.Unstructured { + for k, resource := range sc.resources { + if k.Group == obj.GroupVersionKind().Group && + k.Kind == obj.GetKind() && + // cluster scoped objects will not have a namespace, even if the user has defined it + (k.Namespace == "" || k.Namespace == obj.GetNamespace()) && + k.Name == obj.GetName() { + return resource.Live + } + } + return nil +} + +func (sc *syncContext) setOperationPhase(phase common.OperationPhase, message string) { + if sc.phase != phase || sc.message != message { + sc.log.Info(fmt.Sprintf("Updating operation state. phase: %s -> %s, message: '%s' -> '%s'", sc.phase, phase, sc.message, message)) + } + sc.phase = phase + sc.message = message +} + +// ensureCRDReady waits until specified CRD is ready (established condition is true). +func (sc *syncContext) ensureCRDReady(name string) error { + err := wait.PollUntilContextTimeout(context.Background(), time.Duration(100)*time.Millisecond, crdReadinessTimeout, true, func(_ context.Context) (bool, error) { + crd, err := sc.extensionsclientset.ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), name, metav1.GetOptions{}) + if err != nil { + //nolint:wrapcheck // wrapped outside the retry + return false, err + } + for _, condition := range crd.Status.Conditions { + if condition.Type == apiextensionsv1.Established { + return condition.Status == apiextensionsv1.ConditionTrue, nil + } + } + return false, nil + }) + if err != nil { + return fmt.Errorf("failed to ensure CRD ready: %w", err) + } + return nil +} + +func (sc *syncContext) shouldUseServerSideApply(targetObj *unstructured.Unstructured, dryRun bool) bool { + // if it is a dry run, disable server side apply, as the goal is to validate only the + // yaml correctness of the rendered manifests. + // running dry-run in server mode breaks the auto create namespace feature + // https://github.com/argoproj/argo-cd/issues/13874 + if sc.dryRun || dryRun { + return false + } + + resourceHasDisableSSAAnnotation := resourceutil.HasAnnotationOption(targetObj, common.AnnotationSyncOptions, common.SyncOptionDisableServerSideApply) + if resourceHasDisableSSAAnnotation { + return false + } + + return sc.serverSideApply || resourceutil.HasAnnotationOption(targetObj, common.AnnotationSyncOptions, common.SyncOptionServerSideApply) +} + +// needsClientSideApplyMigration checks if a resource has fields managed by the specified manager +// that need to be migrated to the server-side apply manager +func (sc *syncContext) needsClientSideApplyMigration(liveObj *unstructured.Unstructured, fieldManager string) bool { + if liveObj == nil || fieldManager == "" { + return false + } + + managedFields := liveObj.GetManagedFields() + if len(managedFields) == 0 { + return false + } + + for _, field := range managedFields { + if field.Manager == fieldManager { + return true + } + } + + return false +} + +// performClientSideApplyMigration performs a client-side-apply using the specified field manager. +// This moves the 'last-applied-configuration' field to be managed by the specified manager. +// The next time server-side apply is performed, kubernetes automatically migrates all fields from the manager +// that owns 'last-applied-configuration' to the manager that uses server-side apply. This will remove the +// specified manager from the resources managed fields. 'kubectl-client-side-apply' is used as the default manager. +func (sc *syncContext) performClientSideApplyMigration(targetObj *unstructured.Unstructured, fieldManager string) error { + sc.log.WithValues("resource", kubeutil.GetResourceKey(targetObj)).V(1).Info("Performing client-side apply migration step") + + // Apply with the specified manager to set up the migration + _, err := sc.resourceOps.ApplyResource( + context.TODO(), + targetObj, + cmdutil.DryRunNone, + false, + false, + false, + fieldManager, + ) + if err != nil { + return fmt.Errorf("failed to perform client-side apply migration on manager %s: %w", fieldManager, err) + } + + return nil +} + +func (sc *syncContext) applyObject(t *syncTask, dryRun, validate bool) (common.ResultCode, string) { + dryRunStrategy := cmdutil.DryRunNone + if dryRun { + // irrespective of the dry run mode set in the sync context, always run + // in client dry run mode as the goal is to validate only the + // yaml correctness of the rendered manifests. + // running dry-run in server mode breaks the auto create namespace feature + // https://github.com/argoproj/argo-cd/issues/13874 + dryRunStrategy = cmdutil.DryRunClient + } + + var err error + var message string + shouldReplace := sc.replace || resourceutil.HasAnnotationOption(t.targetObj, common.AnnotationSyncOptions, common.SyncOptionReplace) + force := sc.force || resourceutil.HasAnnotationOption(t.targetObj, common.AnnotationSyncOptions, common.SyncOptionForce) + serverSideApply := sc.shouldUseServerSideApply(t.targetObj, dryRun) + + // Check if we need to perform client-side apply migration for server-side apply + if serverSideApply && !dryRun && sc.enableClientSideApplyMigration { + if sc.needsClientSideApplyMigration(t.liveObj, sc.clientSideApplyMigrationManager) { + err = sc.performClientSideApplyMigration(t.targetObj, sc.clientSideApplyMigrationManager) + if err != nil { + return common.ResultCodeSyncFailed, fmt.Sprintf("Failed to perform client-side apply migration: %v", err) + } + } + } + + if shouldReplace { + if t.liveObj != nil { + // Avoid using `kubectl replace` for CRDs since 'replace' might recreate resource and so delete all CRD instances. + // The same thing applies for namespaces, which would delete the namespace as well as everything within it, + // so we want to avoid using `kubectl replace` in that case as well. + if kubeutil.IsCRD(t.targetObj) || t.targetObj.GetKind() == kubeutil.NamespaceKind { + update := t.targetObj.DeepCopy() + update.SetResourceVersion(t.liveObj.GetResourceVersion()) + _, err = sc.resourceOps.UpdateResource(context.TODO(), update, dryRunStrategy) + if err == nil { + message = fmt.Sprintf("%s/%s updated", t.targetObj.GetKind(), t.targetObj.GetName()) + } else { + message = fmt.Sprintf("error when updating: %v", err.Error()) + } + } else { + message, err = sc.resourceOps.ReplaceResource(context.TODO(), t.targetObj, dryRunStrategy, force) + } + } else { + message, err = sc.resourceOps.CreateResource(context.TODO(), t.targetObj, dryRunStrategy, validate) + } + } else { + message, err = sc.resourceOps.ApplyResource(context.TODO(), t.targetObj, dryRunStrategy, force, validate, serverSideApply, sc.serverSideApplyManager) + } + if err != nil { + return common.ResultCodeSyncFailed, err.Error() + } + if kubeutil.IsCRD(t.targetObj) && !dryRun { + crdName := t.targetObj.GetName() + if err = sc.ensureCRDReady(crdName); err != nil { + sc.log.Error(err, fmt.Sprintf("failed to ensure that CRD %s is ready", crdName)) + } + } + return common.ResultCodeSynced, message +} + +// pruneObject deletes the object if both prune is true and dryRun is false. Otherwise appropriate message +func (sc *syncContext) pruneObject(liveObj *unstructured.Unstructured, prune, dryRun bool) (common.ResultCode, string) { + if !prune { + return common.ResultCodePruneSkipped, "ignored (requires pruning)" + } else if resourceutil.HasAnnotationOption(liveObj, common.AnnotationSyncOptions, common.SyncOptionDisablePrune) { + return common.ResultCodePruneSkipped, "ignored (no prune)" + } + if dryRun { + return common.ResultCodePruned, "pruned (dry run)" + } + // Skip deletion if object is already marked for deletion, so we don't cause a resource update hotloop + deletionTimestamp := liveObj.GetDeletionTimestamp() + if deletionTimestamp == nil || deletionTimestamp.IsZero() { + err := sc.kubectl.DeleteResource(context.TODO(), sc.config, liveObj.GroupVersionKind(), liveObj.GetName(), liveObj.GetNamespace(), sc.getDeleteOptions()) + if err != nil { + return common.ResultCodeSyncFailed, err.Error() + } + } + return common.ResultCodePruned, "pruned" +} + +func (sc *syncContext) getDeleteOptions() metav1.DeleteOptions { + propagationPolicy := metav1.DeletePropagationForeground + if sc.prunePropagationPolicy != nil { + propagationPolicy = *sc.prunePropagationPolicy + } + deleteOption := metav1.DeleteOptions{PropagationPolicy: &propagationPolicy} + return deleteOption +} + +func (sc *syncContext) targetObjs() []*unstructured.Unstructured { + objs := sc.hooks + for _, r := range sc.resources { + if r.Target != nil { + objs = append(objs, r.Target) + } + } + return objs +} + +func isCRDOfGroupKind(group string, kind string, obj *unstructured.Unstructured) bool { + if kubeutil.IsCRD(obj) { + crdGroup, ok, err := unstructured.NestedString(obj.Object, "spec", "group") + if err != nil || !ok { + return false + } + crdKind, ok, err := unstructured.NestedString(obj.Object, "spec", "names", "kind") + if err != nil || !ok { + return false + } + if group == crdGroup && crdKind == kind { + return true + } + } + return false +} + +func (sc *syncContext) hasCRDOfGroupKind(group string, kind string) bool { + for _, obj := range sc.targetObjs() { + if isCRDOfGroupKind(group, kind, obj) { + return true + } + } + return false +} + +// terminate looks for any running jobs/workflow hooks and deletes the resource +func (sc *syncContext) Terminate() { + terminateSuccessful := true + sc.log.V(1).Info("terminating") + tasks, _ := sc.getSyncTasks() + for _, task := range tasks { + if !task.isHook() || task.liveObj == nil { + continue + } + if err := sc.removeHookFinalizer(task); err != nil { + sc.setResourceResult(task, task.syncStatus, common.OperationError, fmt.Sprintf("Failed to remove hook finalizer: %v", err)) + terminateSuccessful = false + continue + } + phase, msg, err := sc.getOperationPhase(task.liveObj) + if err != nil { + sc.setOperationPhase(common.OperationError, fmt.Sprintf("Failed to get hook health: %v", err)) + return + } + if phase == common.OperationRunning { + err := sc.deleteResource(task) + if err != nil && !apierrors.IsNotFound(err) { + sc.setResourceResult(task, "", common.OperationFailed, fmt.Sprintf("Failed to delete: %v", err)) + terminateSuccessful = false + } else { + sc.setResourceResult(task, "", common.OperationSucceeded, "Deleted") + } + } else { + sc.setResourceResult(task, "", phase, msg) + } + } + if terminateSuccessful { + sc.setOperationPhase(common.OperationFailed, "Operation terminated") + } else { + sc.setOperationPhase(common.OperationError, "Operation termination had errors") + } +} + +func (sc *syncContext) deleteResource(task *syncTask) error { + sc.log.WithValues("task", task).V(1).Info("Deleting resource") + resIf, err := sc.getResourceIf(task, "delete") + if err != nil { + return err + } + err = resIf.Delete(context.TODO(), task.name(), sc.getDeleteOptions()) + if err != nil { + return fmt.Errorf("failed to delete resource: %w", err) + } + return nil +} + +func (sc *syncContext) getResourceIf(task *syncTask, verb string) (dynamic.ResourceInterface, error) { + apiResource, err := kubeutil.ServerResourceForGroupVersionKind(sc.disco, task.groupVersionKind(), verb) + if err != nil { + return nil, fmt.Errorf("failed to get api resource: %w", err) + } + res := kubeutil.ToGroupVersionResource(task.groupVersionKind().GroupVersion().String(), apiResource) + resIf := kubeutil.ToResourceInterface(sc.dynamicIf, apiResource, res, task.namespace()) + return resIf, nil +} + +var operationPhases = map[common.ResultCode]common.OperationPhase{ + common.ResultCodeSynced: common.OperationRunning, + common.ResultCodeSyncFailed: common.OperationFailed, + common.ResultCodePruned: common.OperationSucceeded, + common.ResultCodePruneSkipped: common.OperationSucceeded, +} + +// tri-state +type runState int + +const ( + successful runState = iota + pending + failed +) + +func (sc *syncContext) runTasks(tasks syncTasks, dryRun bool) runState { + dryRun = dryRun || sc.dryRun + + sc.log.WithValues("numTasks", len(tasks), "dryRun", dryRun).V(1).Info("Running tasks") + + state := successful + var createTasks syncTasks + var pruneTasks syncTasks + + for _, task := range tasks { + if task.isPrune() { + pruneTasks = append(pruneTasks, task) + } else { + createTasks = append(createTasks, task) + } + } + + // remove finalizers from previous sync on existing hooks to make sure the operation is idempotent + { + ss := newStateSync(state) + existingHooks := tasks.Filter(func(t *syncTask) bool { return t.isHook() && t.pending() && t.liveObj != nil }) + for _, task := range existingHooks { + t := task + ss.Go(func(state runState) runState { + logCtx := sc.log.WithValues("dryRun", dryRun, "task", t) + logCtx.V(1).Info("Removing finalizers") + if !dryRun { + if err := sc.removeHookFinalizer(t); err != nil { + state = failed + sc.setResourceResult(t, t.syncStatus, common.OperationError, fmt.Sprintf("failed to remove hook finalizer: %v", err)) + } + } + return state + }) + } + state = ss.Wait() + } + if state != successful { + return state + } + + // prune first + { + if !sc.pruneConfirmed { + var resources []string + for _, task := range pruneTasks { + if resourceutil.HasAnnotationOption(task.liveObj, common.AnnotationSyncOptions, common.SyncOptionPruneRequireConfirm) { + resources = append(resources, fmt.Sprintf("%s/%s/%s", task.obj().GetAPIVersion(), task.obj().GetKind(), task.name())) + } + } + if len(resources) > 0 { + sc.log.WithValues("resources", resources).Info("Prune requires confirmation") + andMessage := "" + if len(resources) > 1 { + andMessage = fmt.Sprintf(" and %d more resources", len(resources)-1) + } + sc.message = fmt.Sprintf("Waiting for pruning confirmation of %s%s", resources[0], andMessage) + return pending + } + } + + ss := newStateSync(state) + for _, task := range pruneTasks { + t := task + ss.Go(func(state runState) runState { + logCtx := sc.log.WithValues("dryRun", dryRun, "task", t) + logCtx.V(1).Info("Pruning") + result, message := sc.pruneObject(t.liveObj, sc.prune, dryRun) + if result == common.ResultCodeSyncFailed { + state = failed + logCtx.WithValues("message", message).Info("Pruning failed") + } + if !dryRun || sc.dryRun || result == common.ResultCodeSyncFailed { + sc.setResourceResult(t, result, operationPhases[result], message) + } + return state + }) + } + state = ss.Wait() + } + + if state != successful { + return state + } + + // delete anything that need deleting + hooksPendingDeletion := createTasks.Filter(func(t *syncTask) bool { return t.deleteBeforeCreation() }) + if hooksPendingDeletion.Len() > 0 { + ss := newStateSync(state) + for _, task := range hooksPendingDeletion { + t := task + ss.Go(func(state runState) runState { + log := sc.log.WithValues("dryRun", dryRun, "task", t).V(1) + log.Info("Deleting") + if !dryRun { + err := sc.deleteResource(t) + if err != nil { + // it is possible to get a race condition here, such that the resource does not exist when + // delete is requested, we treat this as a nopand remove the liveObj + if !apierrors.IsNotFound(err) { + state = failed + sc.setResourceResult(t, t.syncStatus, common.OperationError, fmt.Sprintf("failed to delete resource: %v", err)) + } else { + log.Info("Resource not found, treating as no-op and removing liveObj") + t.liveObj = nil + } + } else { + // if there is anything that needs deleting, we are at best now in pending and + // want to return and wait for sync to be invoked again + state = pending + } + } + return state + }) + } + state = ss.Wait() + } + + if state != successful { + return state + } + + // finally create resources + var tasksGroup syncTasks + for _, task := range createTasks { + // Only wait if the type of the next task is different than the previous type + if len(tasksGroup) > 0 && tasksGroup[0].targetObj.GetKind() != task.kind() { + state = sc.processCreateTasks(state, tasksGroup, dryRun) + tasksGroup = syncTasks{task} + } else { + tasksGroup = append(tasksGroup, task) + } + } + if len(tasksGroup) > 0 { + state = sc.processCreateTasks(state, tasksGroup, dryRun) + } + return state +} + +func (sc *syncContext) processCreateTasks(state runState, tasks syncTasks, dryRun bool) runState { + ss := newStateSync(state) + for _, task := range tasks { + if dryRun && task.skipDryRun { + continue + } + t := task + ss.Go(func(state runState) runState { + logCtx := sc.log.WithValues("dryRun", dryRun, "task", t) + logCtx.V(1).Info("Applying") + validate := sc.validate && !resourceutil.HasAnnotationOption(t.targetObj, common.AnnotationSyncOptions, common.SyncOptionsDisableValidation) + result, message := sc.applyObject(t, dryRun, validate) + if result == common.ResultCodeSyncFailed { + logCtx.WithValues("message", message).Info("Apply failed") + state = failed + } + if !dryRun || sc.dryRun || result == common.ResultCodeSyncFailed { + phase := operationPhases[result] + // no resources are created in dry-run, so running phase means validation was + // successful and sync operation succeeded + if sc.dryRun && phase == common.OperationRunning { + phase = common.OperationSucceeded + } + sc.setResourceResult(t, result, phase, message) + } + return state + }) + } + return ss.Wait() +} + +// setResourceResult sets a resource details in the SyncResult.Resources list +func (sc *syncContext) setResourceResult(task *syncTask, syncStatus common.ResultCode, operationState common.OperationPhase, message string) { + task.syncStatus = syncStatus + task.operationState = operationState + // we always want to keep the latest message + if message != "" { + task.message = message + } + + sc.lock.Lock() + defer sc.lock.Unlock() + existing, ok := sc.syncRes[task.resultKey()] + + res := common.ResourceSyncResult{ + ResourceKey: kubeutil.GetResourceKey(task.obj()), + Images: kubeutil.GetResourceImages(task.obj()), + Version: task.version(), + Status: task.syncStatus, + Message: task.message, + HookType: task.hookType(), + HookPhase: task.operationState, + SyncPhase: task.phase, + } + + logCtx := sc.log.WithValues("namespace", task.namespace(), "kind", task.kind(), "name", task.name(), "phase", task.phase) + + if ok { + // update existing value + if res.Status != existing.Status || res.HookPhase != existing.HookPhase || res.Message != existing.Message { + logCtx.Info(fmt.Sprintf("Updating resource result, status: '%s' -> '%s', phase '%s' -> '%s', message '%s' -> '%s'", + existing.Status, res.Status, + existing.HookPhase, res.HookPhase, + existing.Message, res.Message)) + existing.Status = res.Status + existing.HookPhase = res.HookPhase + existing.Message = res.Message + } + sc.syncRes[task.resultKey()] = existing + } else { + logCtx.Info(fmt.Sprintf("Adding resource result, status: '%s', phase: '%s', message: '%s'", res.Status, res.HookPhase, res.Message)) + res.Order = len(sc.syncRes) + 1 + sc.syncRes[task.resultKey()] = res + } +} + +func resourceResultKey(key kubeutil.ResourceKey, phase common.SyncPhase) string { + return fmt.Sprintf("%s:%s", key.String(), phase) +} + +type stateSync struct { + wg sync.WaitGroup + results chan runState + currentState runState +} + +func newStateSync(currentState runState) *stateSync { + return &stateSync{ + results: make(chan runState), + currentState: currentState, + } +} + +func (s *stateSync) Go(f func(runState) runState) { + s.wg.Add(1) + go func() { + defer s.wg.Done() + s.results <- f(s.currentState) + }() +} + +func (s *stateSync) Wait() runState { + go func() { + s.wg.Wait() + close(s.results) + }() + res := s.currentState + for result := range s.results { + switch res { + case failed: + // Terminal state, not moving anywhere + case pending: + // Can only move to failed + if result == failed { + res = failed + } + case successful: + switch result { + case pending, failed: + res = result + } + } + } + return res +} diff --git a/gitops-engine/pkg/sync/sync_context_test.go b/gitops-engine/pkg/sync/sync_context_test.go new file mode 100644 index 0000000000000..59f4c52ebd444 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_context_test.go @@ -0,0 +1,2451 @@ +package sync + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "net/http" + "net/http/httptest" + "reflect" + "strings" + "testing" + "time" + + apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/go-logr/logr" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/discovery" + fakedisco "k8s.io/client-go/discovery/fake" + "k8s.io/client-go/dynamic/fake" + "k8s.io/client-go/rest" + testcore "k8s.io/client-go/testing" + "k8s.io/klog/v2/textlogger" + + "github.com/argoproj/gitops-engine/pkg/diff" + "github.com/argoproj/gitops-engine/pkg/health" + synccommon "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/sync/hook" + "github.com/argoproj/gitops-engine/pkg/utils/kube" + "github.com/argoproj/gitops-engine/pkg/utils/kube/kubetest" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +var standardVerbs = metav1.Verbs{"create", "delete", "deletecollection", "get", "list", "patch", "update", "watch"} + +func newTestSyncCtx(getResourceFunc *func(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error), opts ...SyncOpt) *syncContext { + fakeDisco := &fakedisco.FakeDiscovery{Fake: &testcore.Fake{}} + fakeDisco.Resources = append(make([]*metav1.APIResourceList, 0), + &metav1.APIResourceList{ + GroupVersion: "v1", + APIResources: []metav1.APIResource{ + {Name: "pods", Kind: "Pod", Group: "", Version: "v1", Namespaced: true, Verbs: standardVerbs}, + {Name: "services", Kind: "Service", Group: "", Version: "v1", Namespaced: true, Verbs: standardVerbs}, + {Name: "namespaces", Kind: "Namespace", Group: "", Version: "v1", Namespaced: false, Verbs: standardVerbs}, + }, + }, + &metav1.APIResourceList{ + GroupVersion: "apps/v1", + APIResources: []metav1.APIResource{ + {Name: "deployments", Kind: "Deployment", Group: "apps", Version: "v1", Namespaced: true, Verbs: standardVerbs}, + }, + }) + sc := syncContext{ + config: &rest.Config{}, + rawConfig: &rest.Config{}, + namespace: testingutils.FakeArgoCDNamespace, + revision: "FooBarBaz", + disco: fakeDisco, + log: textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app"), + resources: map[kube.ResourceKey]reconciledResource{}, + syncRes: map[string]synccommon.ResourceSyncResult{}, + validate: true, + } + sc.permissionValidator = func(_ *unstructured.Unstructured, _ *metav1.APIResource) error { + return nil + } + mockKubectl := kubetest.MockKubectlCmd{} + + sc.kubectl = &mockKubectl + mockResourceOps := kubetest.MockResourceOps{} + sc.resourceOps = &mockResourceOps + if getResourceFunc != nil { + mockKubectl.WithGetResourceFunc(*getResourceFunc) + mockResourceOps.WithGetResourceFunc(*getResourceFunc) + } + + for _, opt := range opts { + opt(&sc) + } + return &sc +} + +// make sure Validate means we don't validate +func TestSyncValidate(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + pod.SetNamespace("fake-argocd-ns") + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{pod}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.validate = false + + syncCtx.Sync() + + // kubectl := syncCtx.kubectl.(*kubetest.MockKubectlCmd) + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.False(t, resourceOps.GetLastValidate()) +} + +func TestSyncNotPermittedNamespace(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithPermissionValidator(func(_ *unstructured.Unstructured, _ *metav1.APIResource) error { + return errors.New("not permitted in project") + })) + targetPod := testingutils.NewPod() + targetPod.SetNamespace("kube-system") + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, nil}, + Target: []*unstructured.Unstructured{targetPod, testingutils.NewService()}, + }) + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationFailed, phase) + assert.Contains(t, resources[0].Message, "not permitted in project") +} + +func TestSyncNamespaceCreatedBeforeDryRunWithoutFailure(t *testing.T) { + pod := testingutils.NewPod() + syncCtx := newTestSyncCtx(nil, WithNamespaceModifier(func(_, _ *unstructured.Unstructured) (bool, error) { + return true, nil + })) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, nil}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.Sync() + phase, msg, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Equal(t, "waiting for healthy state of /Namespace/fake-argocd-ns", msg) + require.Len(t, resources, 1) + assert.Equal(t, "Namespace", resources[0].ResourceKey.Kind) + assert.Equal(t, synccommon.ResultCodeSynced, resources[0].Status) +} + +func TestSyncNamespaceCreatedBeforeDryRunWithFailure(t *testing.T) { + pod := testingutils.NewPod() + syncCtx := newTestSyncCtx(nil, WithNamespaceModifier(func(_, _ *unstructured.Unstructured) (bool, error) { + return true, nil + }), func(ctx *syncContext) { + resourceOps := ctx.resourceOps.(*kubetest.MockResourceOps) + resourceOps.Commands = map[string]kubetest.KubectlOutput{} + resourceOps.Commands[pod.GetName()] = kubetest.KubectlOutput{ + Output: "should not be returned", + Err: errors.New("invalid object failing dry-run"), + } + }) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, nil}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.Sync() + phase, msg, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationFailed, phase) + assert.Equal(t, "one or more objects failed to apply (dry run)", msg) + require.Len(t, resources, 2) + assert.Equal(t, "Namespace", resources[0].ResourceKey.Kind) + assert.Equal(t, synccommon.ResultCodeSynced, resources[0].Status) + assert.Equal(t, "Pod", resources[1].ResourceKey.Kind) + assert.Equal(t, synccommon.ResultCodeSyncFailed, resources[1].Status) + assert.Equal(t, "invalid object failing dry-run", resources[1].Message) +} + +func TestSyncCreateInSortedOrder(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, nil}, + Target: []*unstructured.Unstructured{testingutils.NewPod(), testingutils.NewService()}, + }) + syncCtx.Sync() + + phase, _, resources := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 2) + for i := range resources { + result := resources[i] + switch result.ResourceKey.Kind { + case "Pod": + assert.Equal(t, synccommon.ResultCodeSynced, result.Status) + assert.Empty(t, result.Message) + case "Service": + assert.Empty(t, result.Message) + default: + t.Error("Resource isn't a pod or a service") + } + } +} + +func TestSyncCustomResources(t *testing.T) { + type fields struct { + skipDryRunAnnotationPresent bool + skipDryRunAnnotationPresentForAllResources bool + crdAlreadyPresent bool + crdInSameSync bool + } + + tests := []struct { + name string + fields fields + wantDryRun bool + wantSuccess bool + }{ + {"unknown crd", fields{ + skipDryRunAnnotationPresent: false, crdAlreadyPresent: false, crdInSameSync: false, + }, true, false}, + {"crd present in same sync", fields{ + skipDryRunAnnotationPresent: false, crdAlreadyPresent: false, crdInSameSync: true, + }, false, true}, + {"crd is already present in cluster", fields{ + skipDryRunAnnotationPresent: false, crdAlreadyPresent: true, crdInSameSync: false, + }, true, true}, + {"crd is already present in cluster, skip dry run annotated", fields{ + skipDryRunAnnotationPresent: true, crdAlreadyPresent: true, crdInSameSync: false, + }, true, true}, + {"unknown crd, skip dry run annotated", fields{ + skipDryRunAnnotationPresent: true, crdAlreadyPresent: false, crdInSameSync: false, + }, false, true}, + {"unknown crd, skip dry run annotated on app level", fields{ + skipDryRunAnnotationPresentForAllResources: true, crdAlreadyPresent: false, crdInSameSync: false, + }, false, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + knownCustomResourceTypes := []metav1.APIResource{} + if tt.fields.crdAlreadyPresent { + knownCustomResourceTypes = append(knownCustomResourceTypes, metav1.APIResource{Kind: "TestCrd", Group: "argoproj.io", Version: "v1", Namespaced: true, Verbs: standardVerbs}) + } + + syncCtx := newTestSyncCtx(nil) + fakeDisco := syncCtx.disco.(*fakedisco.FakeDiscovery) + fakeDisco.Resources = []*metav1.APIResourceList{ + { + GroupVersion: "argoproj.io/v1", + APIResources: knownCustomResourceTypes, + }, + { + GroupVersion: "apiextensions.k8s.io/v1beta1", + APIResources: []metav1.APIResource{ + {Kind: "CustomResourceDefinition", Group: "apiextensions.k8s.io", Version: "v1beta1", Namespaced: true, Verbs: standardVerbs}, + }, + }, + } + + cr := testingutils.Unstructured(` +{ + "apiVersion": "argoproj.io/v1", + "kind": "TestCrd", + "metadata": { + "name": "my-resource" + } +} +`) + + if tt.fields.skipDryRunAnnotationPresent { + cr.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: "SkipDryRunOnMissingResource=true"}) + } + + if tt.fields.skipDryRunAnnotationPresentForAllResources { + syncCtx.skipDryRunOnMissingResource = true + } + + resources := []*unstructured.Unstructured{cr} + if tt.fields.crdInSameSync { + resources = append(resources, testingutils.NewCRD()) + } + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: make([]*unstructured.Unstructured, len(resources)), + Target: resources, + }) + + tasks, successful := syncCtx.getSyncTasks() + + if successful != tt.wantSuccess { + t.Errorf("successful = %v, want: %v", successful, tt.wantSuccess) + return + } + + skipDryRun := false + for _, task := range tasks { + if task.targetObj.GetKind() == cr.GetKind() { + skipDryRun = task.skipDryRun + break + } + } + + assert.Equalf(t, tt.wantDryRun, !skipDryRun, "dryRun = %v, want: %v", !skipDryRun, tt.wantDryRun) + }) + } +} + +func TestSyncSuccessfully(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + pod := testingutils.NewPod() + pod.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod}, + Target: []*unstructured.Unstructured{testingutils.NewService(), nil}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 2) + for i := range resources { + result := resources[i] + switch result.ResourceKey.Kind { + case "Pod": + assert.Equal(t, synccommon.ResultCodePruned, result.Status) + assert.Equal(t, "pruned", result.Message) + case "Service": + assert.Equal(t, synccommon.ResultCodeSynced, result.Status) + assert.Empty(t, result.Message) + default: + t.Error("Resource isn't a pod or a service") + } + } +} + +func TestSyncDeleteSuccessfully(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + svc := testingutils.NewService() + svc.SetNamespace(testingutils.FakeArgoCDNamespace) + pod := testingutils.NewPod() + pod.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{svc, pod}, + Target: []*unstructured.Unstructured{nil, nil}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationSucceeded, phase) + for i := range resources { + result := resources[i] + switch result.ResourceKey.Kind { + case "Pod": + assert.Equal(t, synccommon.ResultCodePruned, result.Status) + assert.Equal(t, "pruned", result.Message) + case "Service": + assert.Equal(t, synccommon.ResultCodePruned, result.Status) + assert.Equal(t, "pruned", result.Message) + default: + t.Error("Resource isn't a pod or a service") + } + } +} + +func TestSyncCreateFailure(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + testSvc := testingutils.NewService() + mockKubectl := &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{ + testSvc.GetName(): { + Output: "", + Err: errors.New("foo"), + }, + }, + } + syncCtx.kubectl = mockKubectl + mockResourceOps := &kubetest.MockResourceOps{ + Commands: map[string]kubetest.KubectlOutput{ + testSvc.GetName(): { + Output: "", + Err: errors.New("foo"), + }, + }, + } + syncCtx.resourceOps = mockResourceOps + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{testSvc}, + }) + + syncCtx.Sync() + _, _, resources := syncCtx.GetState() + + assert.Len(t, resources, 1) + result := resources[0] + assert.Equal(t, synccommon.ResultCodeSyncFailed, result.Status) + assert.Equal(t, "foo", result.Message) +} + +func TestSync_ApplyOutOfSyncOnly(t *testing.T) { + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod1.SetNamespace("fake-argocd-ns") + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod2.SetNamespace("fake-argocd-ns") + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + pod3.SetNamespace("fake-argocd-ns") + + syncCtx := newTestSyncCtx(nil) + syncCtx.applyOutOfSyncOnly = true + t.Run("modificationResult=nil", func(t *testing.T) { + syncCtx.modificationResult = nil + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, pod3}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 3) + }) + + syncCtx = newTestSyncCtx(nil, WithResourceModificationChecker(true, diffResultList())) + t.Run("applyOutOfSyncOnly=true", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, pod3}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 2) + for _, r := range resources { + switch r.ResourceKey.Name { + case "pod-1": + assert.Equal(t, synccommon.ResultCodeSynced, r.Status) + case "pod-2": + assert.Equal(t, synccommon.ResultCodePruneSkipped, r.Status) + case "pod-3": + t.Error("pod-3 should have been skipped, as no change") + } + } + }) + + pod4 := testingutils.NewPod() + pod4.SetName("pod-4") + t.Run("applyOutOfSyncOnly=true and missing resource key", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3, pod4}, + Target: []*unstructured.Unstructured{pod1, nil, pod3, pod4}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 3) + }) + + t.Run("applyOutOfSyncOnly=true and prune=true", func(t *testing.T) { + syncCtx = newTestSyncCtx(nil, WithResourceModificationChecker(true, diffResultList())) + syncCtx.applyOutOfSyncOnly = true + syncCtx.prune = true + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, pod3}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 2) + for _, r := range resources { + switch r.ResourceKey.Name { + case "pod-1": + assert.Equal(t, synccommon.ResultCodeSynced, r.Status) + case "pod-2": + assert.Equal(t, synccommon.ResultCodePruned, r.Status) + case "pod-3": + t.Error("pod-3 should have been skipped, as no change") + } + } + }) + + t.Run("applyOutOfSyncOnly=true and syncwaves", func(t *testing.T) { + syncCtx = newTestSyncCtx(nil, WithResourceModificationChecker(true, diffResultList())) + syncCtx.applyOutOfSyncOnly = true + syncCtx.prune = true + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, pod3}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Len(t, resources, 1) + assert.Equal(t, "pod-1", resources[0].ResourceKey.Name) + assert.Equal(t, synccommon.ResultCodeSynced, resources[0].Status) + assert.Equal(t, synccommon.OperationRunning, resources[0].HookPhase) + + syncCtx.Sync() + phase, _, resources = syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Len(t, resources, 1) + assert.Equal(t, "pod-1", resources[0].ResourceKey.Name) + assert.Equal(t, synccommon.ResultCodeSynced, resources[0].Status) + assert.Equal(t, synccommon.OperationRunning, resources[0].HookPhase) + }) +} + +func TestSync_ApplyOutOfSyncOnly_ClusterResources(t *testing.T) { + ns1 := testingutils.NewNamespace() + ns1.SetName("ns-1") + ns1.SetNamespace("") + + ns2 := testingutils.NewNamespace() + ns2.SetName("ns-2") + ns1.SetNamespace("") + + ns3 := testingutils.NewNamespace() + ns3.SetName("ns-3") + ns3.SetNamespace("") + + ns2Target := testingutils.NewNamespace() + ns2Target.SetName("ns-2") + // set namespace for a cluster scoped resource. This is to simulate the behaviour, where the Application's + // spec.destination.namespace is set for all resources that does not have a namespace set, irrespective of whether + // the resource is cluster scoped or namespace scoped. + // + // Refer to https://github.com/argoproj/gitops-engine/blob/8007df5f6c5dd78a1a8cef73569468ce4d83682c/pkg/sync/sync_context.go#L827-L833 + ns2Target.SetNamespace("ns-2") + + syncCtx := newTestSyncCtx(nil, WithResourceModificationChecker(true, diffResultListClusterResource())) + syncCtx.applyOutOfSyncOnly = true + fakeDisco := syncCtx.disco.(*fakedisco.FakeDiscovery) + fakeDisco.Resources = []*metav1.APIResourceList{ + { + GroupVersion: "v1", + APIResources: []metav1.APIResource{ + {Kind: "Namespace", Group: "", Version: "v1", Namespaced: false, Verbs: standardVerbs}, + }, + }, + } + + t.Run("cluster resource with target ns having namespace filled", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, ns2, ns3}, + Target: []*unstructured.Unstructured{ns1, ns2Target, ns3}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 1) + for _, r := range resources { + switch r.ResourceKey.Name { + case "ns-1": + // ns-1 namespace does not exist yet in the cluster, so it must create it and resource must go to + // synced state. + assert.Equal(t, synccommon.ResultCodeSynced, r.Status) + case "ns-2": + // ns-2 namespace already exist and is synced. However, the target resource has metadata.namespace set for + // a cluster resource. This namespace must not be synced again, as the object already exists and + // a change in namespace for a cluster resource has no meaning and hence must not be treated as an + // out-of-sync resource. + t.Error("ns-2 should have been skipped, as no change") + case "ns-3": + // ns-3 namespace exists and there is no change in the target's metadata.namespace value. So it must not try to sync again. + t.Error("ns-3 should have been skipped, as no change") + } + } + }) +} + +func TestSyncPruneFailure(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + mockKubectl := &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{ + "test-service": { + Output: "", + Err: errors.New("foo"), + }, + }, + } + syncCtx.kubectl = mockKubectl + mockResourceOps := kubetest.MockResourceOps{ + Commands: map[string]kubetest.KubectlOutput{ + "test-service": { + Output: "", + Err: errors.New("foo"), + }, + }, + } + syncCtx.resourceOps = &mockResourceOps + testSvc := testingutils.NewService() + testSvc.SetName("test-service") + testSvc.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{testSvc}, + Target: []*unstructured.Unstructured{testSvc}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationFailed, phase) + assert.Len(t, resources, 1) + result := resources[0] + assert.Equal(t, synccommon.ResultCodeSyncFailed, result.Status) + assert.Equal(t, "foo", result.Message) +} + +type APIServerMock struct { + calls int + errorStatus int + errorBody []byte +} + +func (s *APIServerMock) newHttpServer(t *testing.T, apiFailuresCount int) *httptest.Server { + t.Helper() + stable := metav1.APIResourceList{ + GroupVersion: "v1", + APIResources: []metav1.APIResource{ + {Name: "pods", Namespaced: true, Kind: "Pod"}, + {Name: "services", Namespaced: true, Kind: "Service", Verbs: metav1.Verbs{"get"}}, + {Name: "namespaces", Namespaced: false, Kind: "Namespace"}, + }, + } + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + s.calls++ + if s.calls <= apiFailuresCount { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(s.errorStatus) + w.Write(s.errorBody) // nolint:errcheck + return + } + var list any + switch req.URL.Path { + case "/api/v1": + list = &stable + case "/apis/v1": + list = &stable + default: + t.Logf("unexpected request: %s", req.URL.Path) + w.WriteHeader(http.StatusNotFound) + return + } + + output, err := json.Marshal(list) + if err != nil { + t.Errorf("unexpected encoding error: %v", err) + return + } + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(output) // nolint:errcheck + })) + return server +} + +func TestServerResourcesRetry(t *testing.T) { + type fixture struct { + apiServerMock *APIServerMock + httpServer *httptest.Server + syncCtx *syncContext + } + setup := func(t *testing.T, apiFailuresCount int) *fixture { + t.Helper() + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, false, false, true)) + + unauthorizedStatus := &metav1.Status{ + Status: metav1.StatusFailure, + Code: http.StatusUnauthorized, + Reason: metav1.StatusReasonUnauthorized, + Message: "some error", + } + unauthorizedJSON, err := json.Marshal(unauthorizedStatus) + if err != nil { + t.Errorf("unexpected encoding error while marshaling unauthorizedStatus: %v", err) + return nil + } + server := &APIServerMock{ + errorStatus: http.StatusUnauthorized, + errorBody: unauthorizedJSON, + } + httpServer := server.newHttpServer(t, apiFailuresCount) + + syncCtx.disco = discovery.NewDiscoveryClientForConfigOrDie(&rest.Config{Host: httpServer.URL}) + testSvc := testingutils.NewService() + testSvc.SetName("test-service") + testSvc.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{testSvc, testSvc, testSvc, testSvc}, + Target: []*unstructured.Unstructured{testSvc, testSvc, testSvc, testSvc}, + }) + return &fixture{ + apiServerMock: server, + httpServer: httpServer, + syncCtx: syncCtx, + } + } + type testCase struct { + desc string + apiFailureCount int + apiErrorHTTPStatus int + expectedAPICalls int + expectedResources int + expectedPhase synccommon.OperationPhase + expectedMessage string + } + testCases := []testCase{ + { + desc: "will return success when no api failure", + apiFailureCount: 0, + expectedAPICalls: 1, + expectedResources: 1, + expectedPhase: synccommon.OperationSucceeded, + expectedMessage: "success", + }, + { + desc: "will return success after 1 api failure attempt", + apiFailureCount: 1, + expectedAPICalls: 2, + expectedResources: 1, + expectedPhase: synccommon.OperationSucceeded, + expectedMessage: "success", + }, + { + desc: "will return success after 2 api failure attempt", + apiFailureCount: 2, + expectedAPICalls: 3, + expectedResources: 1, + expectedPhase: synccommon.OperationSucceeded, + expectedMessage: "success", + }, + { + desc: "will return success after 3 api failure attempt", + apiFailureCount: 3, + expectedAPICalls: 4, + expectedResources: 1, + expectedPhase: synccommon.OperationSucceeded, + expectedMessage: "success", + }, + { + desc: "will return success after 4 api failure attempt", + apiFailureCount: 4, + expectedAPICalls: 5, + expectedResources: 1, + expectedPhase: synccommon.OperationSucceeded, + expectedMessage: "success", + }, + { + desc: "will fail after 5 api failure attempt", + apiFailureCount: 5, + expectedAPICalls: 5, + expectedResources: 1, + expectedPhase: synccommon.OperationFailed, + expectedMessage: "not valid", + }, + { + desc: "will not retry if returned error is different than Unauthorized", + apiErrorHTTPStatus: http.StatusConflict, + apiFailureCount: 1, + expectedAPICalls: 1, + expectedResources: 1, + expectedPhase: synccommon.OperationFailed, + expectedMessage: "not valid", + }, + } + for _, tc := range testCases { + tc := tc + t.Run(tc.desc, func(t *testing.T) { + // Given + t.Parallel() + fixture := setup(t, tc.apiFailureCount) + defer fixture.httpServer.Close() + if tc.apiErrorHTTPStatus != 0 { + fixture.apiServerMock.errorStatus = tc.apiErrorHTTPStatus + } + + // When + fixture.syncCtx.Sync() + phase, msg, resources := fixture.syncCtx.GetState() + + // Then + assert.Equal(t, tc.expectedAPICalls, fixture.apiServerMock.calls, "api calls mismatch") + assert.Len(t, resources, tc.expectedResources, "resources len mismatch") + assert.Contains(t, msg, tc.expectedMessage, "expected message mismatch") + require.Equal(t, tc.expectedPhase, phase, "expected phase mismatch") + require.Len(t, fixture.syncCtx.syncRes, 1, "sync result len mismatch") + }) + } +} + +func TestDoNotSyncOrPruneHooks(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, false, false, true)) + targetPod := testingutils.NewPod() + targetPod.SetName("do-not-create-me") + targetPod.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "PreSync"}) + liveSvc := testingutils.NewService() + liveSvc.SetName("do-not-prune-me") + liveSvc.SetNamespace(testingutils.FakeArgoCDNamespace) + liveSvc.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "PreSync"}) + + syncCtx.hooks = []*unstructured.Unstructured{targetPod, liveSvc} + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Empty(t, resources) + assert.Equal(t, synccommon.OperationSucceeded, phase) +} + +// make sure that we do not prune resources with Prune=false +func TestDoNotPrunePruneFalse(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + pod := testingutils.NewPod() + pod.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: "Prune=false"}) + pod.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{pod}, + Target: []*unstructured.Unstructured{nil}, + }) + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, resources, 1) + assert.Equal(t, synccommon.ResultCodePruneSkipped, resources[0].Status) + assert.Equal(t, "ignored (no prune)", resources[0].Message) + + syncCtx.Sync() + + phase, _, _ = syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) +} + +// // make sure Validate=false means we don't validate +func TestSyncOptionValidate(t *testing.T) { + tests := []struct { + name string + annotationVal string + want bool + }{ + {"Empty", "", true}, + {"True", "Validate=true", true}, + {"False", "Validate=false", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + pod.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: tt.annotationVal}) + pod.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{pod}, + Target: []*unstructured.Unstructured{pod}, + }) + + syncCtx.Sync() + + // kubectl, _ := syncCtx.kubectl.(*kubetest.MockKubectlCmd) + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.Equal(t, tt.want, resourceOps.GetLastValidate()) + }) + } +} + +func withReplaceAnnotation(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: synccommon.SyncOptionReplace}) + return un +} + +func TestSync_Replace(t *testing.T) { + testCases := []struct { + name string + target *unstructured.Unstructured + live *unstructured.Unstructured + commandUsed string + }{ + {"NoAnnotation", testingutils.NewPod(), testingutils.NewPod(), "apply"}, + {"AnnotationIsSet", withReplaceAnnotation(testingutils.NewPod()), testingutils.NewPod(), "replace"}, + {"LiveObjectMissing", withReplaceAnnotation(testingutils.NewPod()), nil, "create"}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + + tc.target.SetNamespace(testingutils.FakeArgoCDNamespace) + if tc.live != nil { + tc.live.SetNamespace(testingutils.FakeArgoCDNamespace) + } + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{tc.live}, + Target: []*unstructured.Unstructured{tc.target}, + }) + + syncCtx.Sync() + + // kubectl, _ := syncCtx.kubectl.(*kubetest.MockKubectlCmd) + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.Equal(t, tc.commandUsed, resourceOps.GetLastResourceCommand(kube.GetResourceKey(tc.target))) + }) + } +} + +func withServerSideApplyAnnotation(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: synccommon.SyncOptionServerSideApply}) + return un +} + +func withDisableServerSideApplyAnnotation(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: synccommon.SyncOptionDisableServerSideApply}) + return un +} + +func withReplaceAndServerSideApplyAnnotations(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: "Replace=true,ServerSideApply=true"}) + return un +} + +func TestSync_HookWithReplaceAndBeforeHookCreation_AlreadyDeleted(t *testing.T) { + // This test a race condition when Delete is called on an already deleted object + // LiveObj is set, but then the resource is deleted asynchronously in kubernetes + syncCtx := newTestSyncCtx(nil) + + target := withReplaceAnnotation(testingutils.NewPod()) + target.SetNamespace(testingutils.FakeArgoCDNamespace) + target = testingutils.Annotate(target, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyBeforeHookCreation)) + target = testingutils.Annotate(target, synccommon.AnnotationKeyHook, string(synccommon.SyncPhasePreSync)) + live := target.DeepCopy() + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{live}, + Target: []*unstructured.Unstructured{target}, + }) + syncCtx.hooks = []*unstructured.Unstructured{live} + + client := fake.NewSimpleDynamicClient(runtime.NewScheme()) + deleted := false + client.PrependReactor("delete", "pods", func(_ testcore.Action) (bool, runtime.Object, error) { + deleted = true + // simulate the race conditions where liveObj was not null, but is now deleted in k8s + return true, nil, apierrors.NewNotFound(corev1.Resource("pods"), live.GetName()) + }) + syncCtx.dynamicIf = client + + syncCtx.Sync() + + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.Equal(t, "create", resourceOps.GetLastResourceCommand(kube.GetResourceKey(target))) + assert.True(t, deleted) +} + +func TestSync_ServerSideApply(t *testing.T) { + testCases := []struct { + name string + target *unstructured.Unstructured + live *unstructured.Unstructured + commandUsed string + serverSideApply bool + manager string + }{ + {"NoAnnotation", testingutils.NewPod(), testingutils.NewPod(), "apply", false, "managerA"}, + {"ServerSideApplyAnnotationIsSet", withServerSideApplyAnnotation(testingutils.NewPod()), testingutils.NewPod(), "apply", true, "managerB"}, + {"DisableServerSideApplyAnnotationIsSet", withDisableServerSideApplyAnnotation(testingutils.NewPod()), testingutils.NewPod(), "apply", false, "managerB"}, + {"ServerSideApplyAndReplaceAnnotationsAreSet", withReplaceAndServerSideApplyAnnotations(testingutils.NewPod()), testingutils.NewPod(), "replace", false, ""}, + {"ServerSideApplyAndReplaceAnnotationsAreSetNamespace", withReplaceAndServerSideApplyAnnotations(testingutils.NewNamespace()), testingutils.NewNamespace(), "update", false, ""}, + {"LiveObjectMissing", withReplaceAnnotation(testingutils.NewPod()), nil, "create", false, ""}, + } + + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + syncCtx := newTestSyncCtx(nil) + syncCtx.serverSideApplyManager = tc.manager + + tc.target.SetNamespace(testingutils.FakeArgoCDNamespace) + if tc.live != nil { + tc.live.SetNamespace(testingutils.FakeArgoCDNamespace) + } + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{tc.live}, + Target: []*unstructured.Unstructured{tc.target}, + }) + + syncCtx.Sync() + + // kubectl, _ := syncCtx.kubectl.(*kubetest.MockKubectlCmd) + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.Equal(t, tc.commandUsed, resourceOps.GetLastResourceCommand(kube.GetResourceKey(tc.target))) + assert.Equal(t, tc.serverSideApply, resourceOps.GetLastServerSideApply()) + assert.Equal(t, tc.manager, resourceOps.GetLastServerSideApplyManager()) + }) + } +} + +func TestSyncContext_ServerSideApplyWithDryRun(t *testing.T) { + tests := []struct { + name string + scDryRun bool + dryRun bool + expectedSSA bool + objToUse func(*unstructured.Unstructured) *unstructured.Unstructured + }{ + {"BothFlagsFalseAnnotated", false, false, true, withServerSideApplyAnnotation}, + {"scDryRunTrueAnnotated", true, false, false, withServerSideApplyAnnotation}, + {"dryRunTrueAnnotated", false, true, false, withServerSideApplyAnnotation}, + {"BothFlagsTrueAnnotated", true, true, false, withServerSideApplyAnnotation}, + {"AnnotatedDisabledSSA", false, false, false, withDisableServerSideApplyAnnotation}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + sc := newTestSyncCtx(nil) + sc.dryRun = tc.scDryRun + targetObj := tc.objToUse(testingutils.NewPod()) + + // Execute the shouldUseServerSideApply method and assert expectations + serverSideApply := sc.shouldUseServerSideApply(targetObj, tc.dryRun) + assert.Equal(t, tc.expectedSSA, serverSideApply) + }) + } +} + +func withForceAnnotation(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: synccommon.SyncOptionForce}) + return un +} + +func withForceAndReplaceAnnotations(un *unstructured.Unstructured) *unstructured.Unstructured { + un.SetAnnotations(map[string]string{synccommon.AnnotationSyncOptions: "Force=true,Replace=true"}) + return un +} + +func TestSync_Force(t *testing.T) { + testCases := []struct { + name string + target *unstructured.Unstructured + live *unstructured.Unstructured + commandUsed string + force bool + }{ + {"NoAnnotation", testingutils.NewPod(), testingutils.NewPod(), "apply", false}, + {"ForceApplyAnnotationIsSet", withForceAnnotation(testingutils.NewPod()), testingutils.NewPod(), "apply", true}, + {"ForceReplaceAnnotationIsSet", withForceAndReplaceAnnotations(testingutils.NewPod()), testingutils.NewPod(), "replace", true}, + {"LiveObjectMissing", withReplaceAnnotation(testingutils.NewPod()), nil, "create", false}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + + tc.target.SetNamespace(testingutils.FakeArgoCDNamespace) + if tc.live != nil { + tc.live.SetNamespace(testingutils.FakeArgoCDNamespace) + } + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{tc.live}, + Target: []*unstructured.Unstructured{tc.target}, + }) + + syncCtx.Sync() + + resourceOps, _ := syncCtx.resourceOps.(*kubetest.MockResourceOps) + assert.Equal(t, tc.commandUsed, resourceOps.GetLastResourceCommand(kube.GetResourceKey(tc.target))) + assert.Equal(t, tc.force, resourceOps.GetLastForce()) + }) + } +} + +func TestSelectiveSyncOnly(t *testing.T) { + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + syncCtx := newTestSyncCtx(nil, WithResourcesFilter(func(key kube.ResourceKey, _ *unstructured.Unstructured, _ *unstructured.Unstructured) bool { + return key.Kind == pod1.GetKind() && key.Name == pod1.GetName() + })) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod1}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) + assert.Equal(t, "pod-1", tasks[0].name()) +} + +func TestUnnamedHooksGetUniqueNames(t *testing.T) { + t.Run("Truncated revision", func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + + pod := testingutils.NewPod() + pod.SetName("") + pod.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "PreSync,PostSync"}) + syncCtx.hooks = []*unstructured.Unstructured{pod} + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 2) + assert.Contains(t, tasks[0].name(), "foobarb-presync-") + assert.Contains(t, tasks[1].name(), "foobarb-postsync-") + assert.Empty(t, pod.GetName()) + }) + + t.Run("Short revision", func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + pod.SetName("") + pod.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "PreSync,PostSync"}) + syncCtx.hooks = []*unstructured.Unstructured{pod} + syncCtx.revision = "foobar" + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 2) + assert.Contains(t, tasks[0].name(), "foobar-presync-") + assert.Contains(t, tasks[1].name(), "foobar-postsync-") + assert.Empty(t, pod.GetName()) + }) +} + +func TestManagedResourceAreNotNamed(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + pod.SetName("") + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) + assert.Empty(t, tasks[0].name()) + assert.Empty(t, pod.GetName()) +} + +func TestDeDupingTasks(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + pod := testingutils.NewPod() + pod.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "Sync"}) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.hooks = []*unstructured.Unstructured{pod} + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) +} + +func TestObjectsGetANamespace(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) + assert.Equal(t, testingutils.FakeArgoCDNamespace, tasks[0].namespace()) + assert.Empty(t, pod.GetNamespace()) +} + +func TestNamespaceAutoCreation(t *testing.T) { + pod := testingutils.NewPod() + namespace := testingutils.NewNamespace() + syncCtx := newTestSyncCtx(nil) + syncCtx.namespace = testingutils.FakeArgoCDNamespace + syncCtx.syncNamespace = func(_, _ *unstructured.Unstructured) (bool, error) { + return true, nil + } + namespace.SetName(testingutils.FakeArgoCDNamespace) + + task, err := createNamespaceTask(syncCtx.namespace) + require.NoError(t, err, "Failed creating test data: namespace task") + + // Namespace auto creation pre-sync task should not be there + // since there is namespace resource in syncCtx.resources + t.Run("no pre-sync task if resource is managed", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{namespace}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) + assert.NotContains(t, tasks, task) + }) + + // Namespace auto creation pre-sync task should be there when it is not managed + t.Run("pre-sync task when resource is not managed", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 2) + assert.Contains(t, tasks, task) + }) + + // Namespace auto creation pre-sync task should be there after sync + t.Run("pre-sync task when resource is not managed with existing sync", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + + res := synccommon.ResourceSyncResult{ + ResourceKey: kube.GetResourceKey(task.obj()), + Version: task.version(), + Status: task.syncStatus, + Message: task.message, + HookType: task.hookType(), + HookPhase: task.operationState, + SyncPhase: task.phase, + } + syncCtx.syncRes = map[string]synccommon.ResourceSyncResult{} + syncCtx.syncRes[task.resultKey()] = res + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 2) + assert.Contains(t, tasks, task) + }) + + // Namespace auto creation pre-sync task not should be there + // since there is no namespace modifier present + t.Run("no pre-sync task created if no modifier", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + + syncCtx.syncNamespace = nil + + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 1) + assert.NotContains(t, tasks, task) + }) +} + +func TestNamespaceAutoCreationForNonExistingNs(t *testing.T) { + getResourceFunc := func(_ context.Context, _ *rest.Config, _ schema.GroupVersionKind, _ string, _ string) (*unstructured.Unstructured, error) { + return nil, apierrors.NewNotFound(schema.GroupResource{}, testingutils.FakeArgoCDNamespace) + } + + pod := testingutils.NewPod() + namespace := testingutils.NewNamespace() + syncCtx := newTestSyncCtx(&getResourceFunc) + syncCtx.namespace = testingutils.FakeArgoCDNamespace + namespace.SetName(testingutils.FakeArgoCDNamespace) + + t.Run("pre-sync task should exist and namespace creator should be called", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + creatorCalled := false + syncCtx.syncNamespace = func(_, _ *unstructured.Unstructured) (bool, error) { + creatorCalled = true + return true, nil + } + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, creatorCalled) + assert.True(t, successful) + assert.Len(t, tasks, 2) + }) + + t.Run("pre-sync task should be not created and namespace creator should be called", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + creatorCalled := false + syncCtx.syncNamespace = func(_, _ *unstructured.Unstructured) (bool, error) { + creatorCalled = true + return false, nil + } + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, creatorCalled) + assert.True(t, successful) + assert.Len(t, tasks, 1) + }) + + t.Run("pre-sync task error should be created if namespace creator has an error", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + creatorCalled := false + syncCtx.syncNamespace = func(_, _ *unstructured.Unstructured) (bool, error) { + creatorCalled = true + return false, errors.New("some error") + } + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, creatorCalled) + assert.True(t, successful) + assert.Len(t, tasks, 2) + assert.Equal(t, &syncTask{ + phase: synccommon.SyncPhasePreSync, + liveObj: nil, + targetObj: tasks[0].targetObj, + skipDryRun: false, + syncStatus: synccommon.ResultCodeSyncFailed, + operationState: synccommon.OperationError, + message: "namespaceModifier error: some error", + waveOverride: nil, + }, tasks[0]) + }) +} + +func createNamespaceTask(namespace string) (*syncTask, error) { + nsSpec := &corev1.Namespace{TypeMeta: metav1.TypeMeta{APIVersion: "v1", Kind: kube.NamespaceKind}, ObjectMeta: metav1.ObjectMeta{Name: namespace}} + unstructuredObj, err := kube.ToUnstructured(nsSpec) + + task := &syncTask{phase: synccommon.SyncPhasePreSync, targetObj: unstructuredObj} + if err != nil { + return task, fmt.Errorf("failed to convert namespace spec to unstructured: %w", err) + } + return task, nil +} + +func TestSyncFailureHookWithSuccessfulSync(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{testingutils.NewPod()}, + }) + syncCtx.hooks = []*unstructured.Unstructured{newHook(synccommon.HookTypeSyncFail)} + + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + // only one result, we did not run the failure failureHook + assert.Len(t, resources, 1) +} + +func TestSyncFailureHookWithFailedSync(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.hooks = []*unstructured.Unstructured{newHook(synccommon.HookTypeSyncFail)} + mockKubectl := &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{pod.GetName(): {Err: errors.New("")}}, + } + syncCtx.kubectl = mockKubectl + mockResourceOps := kubetest.MockResourceOps{ + Commands: map[string]kubetest.KubectlOutput{pod.GetName(): {Err: errors.New("")}}, + } + syncCtx.resourceOps = &mockResourceOps + + syncCtx.Sync() + syncCtx.Sync() + + phase, _, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationFailed, phase) + assert.Len(t, resources, 2) +} + +func TestBeforeHookCreation(t *testing.T) { + finalizerRemoved := false + syncCtx := newTestSyncCtx(nil) + hookObj := testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), synccommon.AnnotationKeyHook, "Sync"), synccommon.AnnotationKeyHookDeletePolicy, "BeforeHookCreation") + hookObj.SetFinalizers([]string{hook.HookFinalizer}) + hookObj.SetNamespace(testingutils.FakeArgoCDNamespace) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{hookObj}, + Target: []*unstructured.Unstructured{nil}, + }) + syncCtx.hooks = []*unstructured.Unstructured{hookObj} + client := fake.NewSimpleDynamicClient(runtime.NewScheme(), hookObj) + client.PrependReactor("update", "pods", func(_ testcore.Action) (bool, runtime.Object, error) { + finalizerRemoved = true + return false, nil, nil + }) + syncCtx.dynamicIf = client + + // First sync will delete the existing hook + syncCtx.Sync() + phase, _, _ := syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.True(t, finalizerRemoved) + + // Second sync will create the hook + syncCtx.Sync() + phase, message, resources := syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Len(t, resources, 1) + assert.Equal(t, synccommon.OperationRunning, resources[0].HookPhase) + assert.Equal(t, "waiting for completion of hook /Pod/my-pod", message) +} + +func TestSync_ExistingHooksWithFinalizer(t *testing.T) { + newHook := func(name string, hookType synccommon.HookType, deletePolicy synccommon.HookDeletePolicy) *unstructured.Unstructured { + obj := testingutils.NewPod() + obj.SetName(name) + obj.SetNamespace(testingutils.FakeArgoCDNamespace) + testingutils.Annotate(obj, synccommon.AnnotationKeyHook, string(hookType)) + testingutils.Annotate(obj, synccommon.AnnotationKeyHookDeletePolicy, string(deletePolicy)) + obj.SetFinalizers([]string{hook.HookFinalizer}) + return obj + } + + hook1 := newHook("existing-hook-1", synccommon.HookTypePreSync, synccommon.HookDeletePolicyBeforeHookCreation) + hook2 := newHook("existing-hook-2", synccommon.HookTypePreSync, synccommon.HookDeletePolicyHookFailed) + hook3 := newHook("existing-hook-3", synccommon.HookTypePreSync, synccommon.HookDeletePolicyHookSucceeded) + + syncCtx := newTestSyncCtx(nil) + fakeDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme(), hook1, hook2, hook3) + syncCtx.dynamicIf = fakeDynamicClient + updatedCount := 0 + fakeDynamicClient.PrependReactor("update", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + // Removing the finalizers + updatedCount++ + return false, nil, nil + }) + deletedCount := 0 + fakeDynamicClient.PrependReactor("delete", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + // because of HookDeletePolicyBeforeHookCreation + deletedCount++ + return false, nil, nil + }) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{hook1, hook2, hook3}, + Target: []*unstructured.Unstructured{nil, nil, nil}, + }) + syncCtx.hooks = []*unstructured.Unstructured{hook1, hook2, hook3} + + syncCtx.Sync() + phase, _, _ := syncCtx.GetState() + + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Equal(t, 3, updatedCount) + assert.Equal(t, 1, deletedCount) + + _, err := syncCtx.getResource(&syncTask{liveObj: hook1}) + require.Error(t, err, "Expected resource to be deleted") + assert.True(t, apierrors.IsNotFound(err)) +} + +func TestRunSyncFailHooksFailed(t *testing.T) { + // Tests that other SyncFail Hooks run even if one of them fail. + + syncCtx := newTestSyncCtx(nil) + pod := testingutils.NewPod() + successfulSyncFailHook := newHook(synccommon.HookTypeSyncFail) + successfulSyncFailHook.SetName("successful-sync-fail-hook") + failedSyncFailHook := newHook(synccommon.HookTypeSyncFail) + failedSyncFailHook.SetName("failed-sync-fail-hook") + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod}, + }) + syncCtx.hooks = []*unstructured.Unstructured{successfulSyncFailHook, failedSyncFailHook} + + mockKubectl := &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{ + // Fail operation + pod.GetName(): {Err: errors.New("")}, + // Fail a single SyncFail hook + failedSyncFailHook.GetName(): {Err: errors.New("")}, + }, + } + syncCtx.kubectl = mockKubectl + mockResourceOps := kubetest.MockResourceOps{ + Commands: map[string]kubetest.KubectlOutput{ + // Fail operation + pod.GetName(): {Err: errors.New("")}, + // Fail a single SyncFail hook + failedSyncFailHook.GetName(): {Err: errors.New("")}, + }, + } + syncCtx.resourceOps = &mockResourceOps + + syncCtx.Sync() + syncCtx.Sync() + phase, _, resources := syncCtx.GetState() + + // Operation as a whole should fail + assert.Equal(t, synccommon.OperationFailed, phase) + // failedSyncFailHook should fail + assert.Equal(t, synccommon.OperationFailed, resources[1].HookPhase) + assert.Equal(t, synccommon.ResultCodeSyncFailed, resources[1].Status) + // successfulSyncFailHook should be synced running (it is an nginx pod) + assert.Equal(t, synccommon.OperationRunning, resources[2].HookPhase) + assert.Equal(t, synccommon.ResultCodeSynced, resources[2].Status) +} + +type resourceNameHealthOverride map[string]health.HealthStatusCode + +func (r resourceNameHealthOverride) GetResourceHealth(obj *unstructured.Unstructured) (*health.HealthStatus, error) { + if status, ok := r[obj.GetName()]; ok { + return &health.HealthStatus{Status: status, Message: "test"}, nil + } + return nil, nil +} + +func TestRunSync_HooksNotDeletedIfPhaseNotCompleted(t *testing.T) { + hook1 := newHook(synccommon.HookTypePreSync) + hook1.SetName("completed-hook") + hook1.SetNamespace(testingutils.FakeArgoCDNamespace) + _ = testingutils.Annotate(hook1, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookSucceeded)) + completedHook := hook1.DeepCopy() + completedHook.SetFinalizers(append(completedHook.GetFinalizers(), hook.HookFinalizer)) + + hook2 := newHook(synccommon.HookTypePreSync) + hook2.SetNamespace(testingutils.FakeArgoCDNamespace) + hook2.SetName("in-progress-hook") + _ = testingutils.Annotate(hook2, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookSucceeded)) + inProgressHook := hook2.DeepCopy() + inProgressHook.SetFinalizers(append(inProgressHook.GetFinalizers(), hook.HookFinalizer)) + + syncCtx := newTestSyncCtx(nil, + WithHealthOverride(resourceNameHealthOverride(map[string]health.HealthStatusCode{ + inProgressHook.GetName(): health.HealthStatusProgressing, + })), + WithInitialState(synccommon.OperationRunning, "", []synccommon.ResourceSyncResult{{ + ResourceKey: kube.GetResourceKey(completedHook), + HookPhase: synccommon.OperationSucceeded, + SyncPhase: synccommon.SyncPhasePreSync, + }, { + ResourceKey: kube.GetResourceKey(inProgressHook), + HookPhase: synccommon.OperationRunning, + SyncPhase: synccommon.SyncPhasePreSync, + }}, + metav1.Now(), + )) + fakeDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) + syncCtx.dynamicIf = fakeDynamicClient + updatedCount := 0 + fakeDynamicClient.PrependReactor("update", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + // Removing the finalizers + updatedCount++ + return true, nil, nil + }) + deletedCount := 0 + fakeDynamicClient.PrependReactor("delete", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + deletedCount++ + return true, nil, nil + }) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{completedHook, inProgressHook}, + Target: []*unstructured.Unstructured{nil, nil}, + }) + syncCtx.hooks = []*unstructured.Unstructured{hook1, hook2} + + syncCtx.kubectl = &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{}, + } + + syncCtx.Sync() + + assert.Equal(t, synccommon.OperationRunning, syncCtx.phase) + assert.Equal(t, 0, updatedCount) + assert.Equal(t, 0, deletedCount) +} + +func TestRunSync_HooksDeletedAfterPhaseCompleted(t *testing.T) { + hook1 := newHook(synccommon.HookTypePreSync) + hook1.SetName("completed-hook1") + hook1.SetNamespace(testingutils.FakeArgoCDNamespace) + _ = testingutils.Annotate(hook1, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookSucceeded)) + completedHook1 := hook1.DeepCopy() + completedHook1.SetFinalizers(append(completedHook1.GetFinalizers(), hook.HookFinalizer)) + + hook2 := newHook(synccommon.HookTypePreSync) + hook2.SetNamespace(testingutils.FakeArgoCDNamespace) + hook2.SetName("completed-hook2") + _ = testingutils.Annotate(hook2, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookSucceeded)) + completedHook2 := hook2.DeepCopy() + completedHook2.SetFinalizers(append(completedHook1.GetFinalizers(), hook.HookFinalizer)) + + syncCtx := newTestSyncCtx(nil, + WithInitialState(synccommon.OperationRunning, "", []synccommon.ResourceSyncResult{{ + ResourceKey: kube.GetResourceKey(completedHook1), + HookPhase: synccommon.OperationSucceeded, + SyncPhase: synccommon.SyncPhasePreSync, + }, { + ResourceKey: kube.GetResourceKey(completedHook2), + HookPhase: synccommon.OperationSucceeded, + SyncPhase: synccommon.SyncPhasePreSync, + }}, + metav1.Now(), + )) + fakeDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) + syncCtx.dynamicIf = fakeDynamicClient + updatedCount := 0 + fakeDynamicClient.PrependReactor("update", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + // Removing the finalizers + updatedCount++ + return true, nil, nil + }) + deletedCount := 0 + fakeDynamicClient.PrependReactor("delete", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + deletedCount++ + return true, nil, nil + }) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{completedHook1, completedHook2}, + Target: []*unstructured.Unstructured{nil, nil}, + }) + syncCtx.hooks = []*unstructured.Unstructured{hook1, hook2} + + syncCtx.kubectl = &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{}, + } + + syncCtx.Sync() + + assert.Equal(t, synccommon.OperationSucceeded, syncCtx.phase) + assert.Equal(t, 2, updatedCount) + assert.Equal(t, 2, deletedCount) +} + +func TestRunSync_HooksDeletedAfterPhaseCompletedFailed(t *testing.T) { + hook1 := newHook(synccommon.HookTypeSync) + hook1.SetName("completed-hook1") + hook1.SetNamespace(testingutils.FakeArgoCDNamespace) + _ = testingutils.Annotate(hook1, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookFailed)) + completedHook1 := hook1.DeepCopy() + completedHook1.SetFinalizers(append(completedHook1.GetFinalizers(), hook.HookFinalizer)) + + hook2 := newHook(synccommon.HookTypeSync) + hook2.SetNamespace(testingutils.FakeArgoCDNamespace) + hook2.SetName("completed-hook2") + _ = testingutils.Annotate(hook2, synccommon.AnnotationKeyHookDeletePolicy, string(synccommon.HookDeletePolicyHookFailed)) + completedHook2 := hook2.DeepCopy() + completedHook2.SetFinalizers(append(completedHook1.GetFinalizers(), hook.HookFinalizer)) + + syncCtx := newTestSyncCtx(nil, + WithInitialState(synccommon.OperationRunning, "", []synccommon.ResourceSyncResult{{ + ResourceKey: kube.GetResourceKey(completedHook1), + HookPhase: synccommon.OperationSucceeded, + SyncPhase: synccommon.SyncPhaseSync, + }, { + ResourceKey: kube.GetResourceKey(completedHook2), + HookPhase: synccommon.OperationFailed, + SyncPhase: synccommon.SyncPhaseSync, + }}, + metav1.Now(), + )) + fakeDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) + syncCtx.dynamicIf = fakeDynamicClient + updatedCount := 0 + fakeDynamicClient.PrependReactor("update", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + // Removing the finalizers + updatedCount++ + return true, nil, nil + }) + deletedCount := 0 + fakeDynamicClient.PrependReactor("delete", "*", func(_ testcore.Action) (handled bool, ret runtime.Object, err error) { + deletedCount++ + return true, nil, nil + }) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{completedHook1, completedHook2}, + Target: []*unstructured.Unstructured{nil, nil}, + }) + syncCtx.hooks = []*unstructured.Unstructured{hook1, hook2} + + syncCtx.kubectl = &kubetest.MockKubectlCmd{ + Commands: map[string]kubetest.KubectlOutput{}, + } + + syncCtx.Sync() + + assert.Equal(t, synccommon.OperationFailed, syncCtx.phase) + assert.Equal(t, 2, updatedCount) + assert.Equal(t, 2, deletedCount) +} + +func Test_syncContext_liveObj(t *testing.T) { + type fields struct { + compareResult ReconciliationResult + } + type args struct { + obj *unstructured.Unstructured + } + obj := testingutils.NewPod() + obj.SetNamespace("my-ns") + + found := testingutils.NewPod() + foundNoNamespace := testingutils.NewPod() + foundNoNamespace.SetNamespace("") + + tests := []struct { + name string + fields fields + args args + want *unstructured.Unstructured + }{ + {"None", fields{compareResult: ReconciliationResult{}}, args{obj: &unstructured.Unstructured{}}, nil}, + {"Found", fields{compareResult: ReconciliationResult{Target: []*unstructured.Unstructured{nil}, Live: []*unstructured.Unstructured{found}}}, args{obj: obj}, found}, + {"EmptyNamespace", fields{compareResult: ReconciliationResult{Target: []*unstructured.Unstructured{nil}, Live: []*unstructured.Unstructured{foundNoNamespace}}}, args{obj: obj}, found}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sc := &syncContext{ + resources: groupResources(tt.fields.compareResult), + hooks: tt.fields.compareResult.Hooks, + } + got := sc.liveObj(tt.args.obj) + assert.Truef(t, reflect.DeepEqual(got, tt.want), "syncContext.liveObj() = %v, want %v", got, tt.want) + }) + } +} + +func Test_syncContext_hasCRDOfGroupKind(t *testing.T) { + // target + assert.False(t, (&syncContext{resources: groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{testingutils.NewCRD()}, + })}).hasCRDOfGroupKind("", "")) + assert.True(t, (&syncContext{resources: groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{testingutils.NewCRD()}, + })}).hasCRDOfGroupKind("argoproj.io", "TestCrd")) + + // hook + assert.False(t, (&syncContext{hooks: []*unstructured.Unstructured{testingutils.NewCRD()}}).hasCRDOfGroupKind("", "")) + assert.True(t, (&syncContext{hooks: []*unstructured.Unstructured{testingutils.NewCRD()}}).hasCRDOfGroupKind("argoproj.io", "TestCrd")) +} + +func Test_setRunningPhase_healthyState(t *testing.T) { + var sc syncContext + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + sc.setRunningPhase([]*syncTask{{targetObj: testingutils.NewPod()}, {targetObj: testingutils.NewPod()}, {targetObj: testingutils.NewPod()}}, false) + + assert.Equal(t, "waiting for healthy state of /Pod/my-pod and 2 more resources", sc.message) +} + +func Test_setRunningPhase_runningHooks(t *testing.T) { + var sc syncContext + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + sc.setRunningPhase([]*syncTask{{targetObj: newHook(synccommon.HookTypeSyncFail)}}, false) + + assert.Equal(t, "waiting for completion of hook /Pod/my-pod", sc.message) +} + +func Test_setRunningPhase_pendingDeletion(t *testing.T) { + var sc syncContext + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + sc.setRunningPhase([]*syncTask{{targetObj: testingutils.NewPod()}, {targetObj: testingutils.NewPod()}, {targetObj: testingutils.NewPod()}}, true) + + assert.Equal(t, "waiting for deletion of /Pod/my-pod and 2 more resources", sc.message) +} + +func TestSyncWaveHook(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, false, false, false)) + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "-1"}) + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + pod3.SetAnnotations(map[string]string{synccommon.AnnotationKeyHook: "PostSync"}) + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, nil}, + Target: []*unstructured.Unstructured{pod1, pod2}, + }) + syncCtx.hooks = []*unstructured.Unstructured{pod3} + + called := false + syncCtx.syncWaveHook = func(phase synccommon.SyncPhase, wave int, final bool) error { + called = true + assert.Equal(t, synccommon.SyncPhaseSync, string(phase)) + assert.Equal(t, -1, wave) + assert.False(t, final) + return nil + } + syncCtx.Sync() + assert.True(t, called) + + // call sync again, it should not invoke the SyncWaveHook callback since we only should be + // doing this after an apply, and not every reconciliation + called = false + syncCtx.syncWaveHook = func(_ synccommon.SyncPhase, _ int, _ bool) error { + called = true + return nil + } + syncCtx.Sync() + assert.False(t, called) + + // complete wave -1, then call Sync again. Verify we invoke another SyncWaveHook call after applying wave 0 + _, _, results := syncCtx.GetState() + pod1Res := results[0] + pod1Res.HookPhase = synccommon.OperationSucceeded + syncCtx.syncRes[resourceResultKey(pod1Res.ResourceKey, synccommon.SyncPhaseSync)] = pod1Res + called = false + syncCtx.syncWaveHook = func(phase synccommon.SyncPhase, wave int, final bool) error { + called = true + assert.Equal(t, synccommon.SyncPhaseSync, string(phase)) + assert.Equal(t, 0, wave) + assert.False(t, final) + return nil + } + syncCtx.Sync() + assert.True(t, called) + + // complete wave 0. after applying PostSync, we should perform callback and final should be set true + _, _, results = syncCtx.GetState() + pod2Res := results[1] + pod2Res.HookPhase = synccommon.OperationSucceeded + syncCtx.syncRes[resourceResultKey(pod2Res.ResourceKey, synccommon.SyncPhaseSync)] = pod2Res + called = false + syncCtx.syncWaveHook = func(phase synccommon.SyncPhase, wave int, final bool) error { + called = true + assert.Equal(t, synccommon.SyncPhasePostSync, string(phase)) + assert.Equal(t, 0, wave) + assert.True(t, final) + return nil + } + syncCtx.Sync() + assert.True(t, called) +} + +func TestSyncWaveHookFail(t *testing.T) { + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, false, false, false)) + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil}, + Target: []*unstructured.Unstructured{pod1}, + }) + + called := false + syncCtx.syncWaveHook = func(_ synccommon.SyncPhase, _ int, _ bool) error { + called = true + return errors.New("intentional error") + } + syncCtx.Sync() + assert.True(t, called) + phase, msg, results := syncCtx.GetState() + assert.Equal(t, synccommon.OperationFailed, phase) + assert.Equal(t, "SyncWaveHook failed: intentional error", msg) + assert.Equal(t, synccommon.OperationRunning, results[0].HookPhase) +} + +func TestPruneLast(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + syncCtx.pruneLast = true + + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + + t.Run("syncPhaseSameWave", func(t *testing.T) { + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, nil}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 3) + // last wave is the last sync wave for non-prune task + 1 + assert.Equal(t, 1, tasks.lastWave()) + }) + + t.Run("syncPhaseDifferentWave", func(t *testing.T) { + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "7"}) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, nil}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 3) + // last wave is the last sync wave for tasks + 1 + assert.Equal(t, 8, tasks.lastWave()) + }) + + t.Run("pruneLastIndividualResources", func(t *testing.T) { + syncCtx.pruneLast = false + + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1", synccommon.AnnotationSyncOptions: synccommon.SyncOptionPruneLast}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "7", synccommon.AnnotationSyncOptions: synccommon.SyncOptionPruneLast}) + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod2, pod3}, + Target: []*unstructured.Unstructured{pod1, nil, nil}, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, 3) + // last wave is the last sync wave for tasks + 1 + assert.Equal(t, 8, tasks.lastWave()) + }) +} + +func diffResultList() *diff.DiffResultList { + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod1.SetNamespace(testingutils.FakeArgoCDNamespace) + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod2.SetNamespace(testingutils.FakeArgoCDNamespace) + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + pod3.SetNamespace(testingutils.FakeArgoCDNamespace) + + diffResultList := diff.DiffResultList{ + Modified: true, + Diffs: []diff.DiffResult{}, + } + + podBytes, _ := json.Marshal(pod1) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: []byte("null"), PredictedLive: podBytes, Modified: true}) + + podBytes, _ = json.Marshal(pod2) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: podBytes, PredictedLive: []byte("null"), Modified: true}) + + podBytes, _ = json.Marshal(pod3) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: podBytes, PredictedLive: podBytes, Modified: false}) + + return &diffResultList +} + +func TestSyncContext_GetDeleteOptions_Default(t *testing.T) { + sc := syncContext{} + opts := sc.getDeleteOptions() + assert.Equal(t, metav1.DeletePropagationForeground, *opts.PropagationPolicy) +} + +func TestSyncContext_GetDeleteOptions_WithPrunePropagationPolicy(t *testing.T) { + sc := syncContext{} + + policy := metav1.DeletePropagationBackground + WithPrunePropagationPolicy(&policy)(&sc) + + opts := sc.getDeleteOptions() + assert.Equal(t, metav1.DeletePropagationBackground, *opts.PropagationPolicy) +} + +func TestSetOperationFailed(t *testing.T) { + sc := syncContext{} + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + tasks := make([]*syncTask, 0) + tasks = append(tasks, &syncTask{message: "namespace not found"}) + + sc.setOperationFailed(nil, tasks, "one or more objects failed to apply") + + assert.Equal(t, "one or more objects failed to apply, reason: namespace not found", sc.message) +} + +func TestSetOperationFailedDuplicatedMessages(t *testing.T) { + sc := syncContext{} + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + tasks := make([]*syncTask, 0) + tasks = append(tasks, &syncTask{message: "namespace not found"}) + tasks = append(tasks, &syncTask{message: "namespace not found"}) + + sc.setOperationFailed(nil, tasks, "one or more objects failed to apply") + + assert.Equal(t, "one or more objects failed to apply, reason: namespace not found", sc.message) +} + +func TestSetOperationFailedNoTasks(t *testing.T) { + sc := syncContext{} + sc.log = textlogger.NewLogger(textlogger.NewConfig()).WithValues("application", "fake-app") + + sc.setOperationFailed(nil, nil, "one or more objects failed to apply") + + assert.Equal(t, "one or more objects failed to apply", sc.message) +} + +func TestWaveReorderingOfPruneTasks(t *testing.T) { + ns := testingutils.NewNamespace() + ns.SetName("ns") + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + pod4 := testingutils.NewPod() + pod4.SetName("pod-4") + pod5 := testingutils.NewPod() + pod5.SetName("pod-5") + pod6 := testingutils.NewPod() + pod6.SetName("pod-6") + pod7 := testingutils.NewPod() + pod7.SetName("pod-7") + + type Test struct { + name string + target []*unstructured.Unstructured + live []*unstructured.Unstructured + expectedWaveOrder map[string]int + pruneLast bool + } + runTest := func(test Test) { + t.Run(test.name, func(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + syncCtx.pruneLast = test.pruneLast + syncCtx.resources = groupResources(ReconciliationResult{ + Live: test.live, + Target: test.target, + }) + tasks, successful := syncCtx.getSyncTasks() + + assert.True(t, successful) + assert.Len(t, tasks, len(test.target)) + + for _, task := range tasks { + assert.Equal(t, test.expectedWaveOrder[task.name()], task.wave()) + } + }) + } + + // same wave + sameWaveTests := []Test{ + { + name: "sameWave_noPruneTasks", + live: []*unstructured.Unstructured{nil, nil, nil, nil, nil}, + target: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + // no change in wave order + expectedWaveOrder: map[string]int{ns.GetName(): 0, pod1.GetName(): 0, pod2.GetName(): 0, pod3.GetName(): 0, pod4.GetName(): 0}, + }, + { + name: "sameWave_allPruneTasks", + live: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + target: []*unstructured.Unstructured{nil, nil, nil, nil, nil}, + // no change in wave order + expectedWaveOrder: map[string]int{ns.GetName(): 0, pod1.GetName(): 0, pod2.GetName(): 0, pod3.GetName(): 0, pod4.GetName(): 0}, + }, + { + name: "sameWave_mixedTasks", + live: []*unstructured.Unstructured{ns, pod1, nil, pod3, pod4}, + target: []*unstructured.Unstructured{ns, nil, pod2, nil, nil}, + // no change in wave order + expectedWaveOrder: map[string]int{ns.GetName(): 0, pod1.GetName(): 0, pod2.GetName(): 0, pod3.GetName(): 0, pod4.GetName(): 0}, + }, + } + + for _, test := range sameWaveTests { + runTest(test) + } + + // different wave + differentWaveTests := []Test{ + { + name: "differentWave_noPruneTasks", + target: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + live: []*unstructured.Unstructured{nil, nil, nil, nil, nil}, + // no change in wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + ns.GetName(): 0, // 0 + pod1.GetName(): 1, // 1 + pod2.GetName(): 2, // 2 + pod3.GetName(): 3, // 3 + pod4.GetName(): 4, // 4 + }, + }, + { + name: "differentWave_allPruneTasks", + target: []*unstructured.Unstructured{nil, nil, nil, nil, nil}, + live: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + // change in prune wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + ns.GetName(): 4, // 0 + pod1.GetName(): 3, // 1 + pod2.GetName(): 2, // 2 + pod3.GetName(): 1, // 3 + pod4.GetName(): 0, // 4 + }, + }, + { + name: "differentWave_mixedTasks", + target: []*unstructured.Unstructured{ns, nil, pod2, nil, nil}, + live: []*unstructured.Unstructured{ns, pod1, nil, pod3, pod4}, + // change in prune wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + pod1.GetName(): 4, // 1 + pod3.GetName(): 3, // 3 + pod4.GetName(): 1, // 4 + + // no change since non prune tasks + ns.GetName(): 0, // 0 + pod2.GetName(): 2, // 2 + }, + }, + } + + for _, test := range differentWaveTests { + ns.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "0"}) + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2"}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod4.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "4"}) + + runTest(test) + } + + // prune last + pruneLastTests := []Test{ + { + name: "pruneLast", + pruneLast: true, + live: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + target: []*unstructured.Unstructured{ns, nil, nil, nil, nil}, + // change in prune wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + pod1.GetName(): 5, // 1 + pod2.GetName(): 5, // 2 + pod3.GetName(): 5, // 3 + pod4.GetName(): 5, // 4 + + // no change since non prune tasks + ns.GetName(): 0, // 0 + }, + }, + { + name: "pruneLastIndividualResources", + pruneLast: false, + live: []*unstructured.Unstructured{ns, pod1, pod2, pod3, pod4}, + target: []*unstructured.Unstructured{ns, nil, nil, nil, nil}, + // change in wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + pod1.GetName(): 4, // 1 + pod2.GetName(): 5, // 2 + pod3.GetName(): 2, // 3 + pod4.GetName(): 1, // 4 + + // no change since non prune tasks + ns.GetName(): 0, // 0 + }, + }, + } + + for _, test := range pruneLastTests { + ns.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "0"}) + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2", synccommon.AnnotationSyncOptions: synccommon.SyncOptionPruneLast}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod4.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "4"}) + + runTest(test) + } + + // additional test + tests := []Test{ + { + name: "mixedTasks", + target: []*unstructured.Unstructured{ns, nil, pod2, nil, nil, nil, pod6, nil}, + live: []*unstructured.Unstructured{ns, pod1, nil, pod3, pod4, pod5, pod6, pod7}, + // change in prune wave order + expectedWaveOrder: map[string]int{ + // new wave // original wave + pod1.GetName(): 5, // 1 + pod3.GetName(): 4, // 3 + pod4.GetName(): 4, // 3 + pod5.GetName(): 3, // 4 + pod7.GetName(): 1, // 5 + + // no change since non prune tasks + ns.GetName(): -1, // -1 + pod2.GetName(): 3, // 3 + pod6.GetName(): 5, // 5 + }, + }, + } + for _, test := range tests { + ns.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "-1"}) + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod4.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + pod5.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "4"}) + pod6.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "5"}) + pod7.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "5"}) + + runTest(test) + } +} + +func TestWaitForCleanUpBeforeNextWave(t *testing.T) { + pod1 := testingutils.NewPod() + pod1.SetName("pod-1") + pod2 := testingutils.NewPod() + pod2.SetName("pod-2") + pod3 := testingutils.NewPod() + pod3.SetName("pod-3") + + pod1.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "1"}) + pod2.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "2"}) + pod3.SetAnnotations(map[string]string{synccommon.AnnotationSyncWave: "3"}) + + syncCtx := newTestSyncCtx(nil) + syncCtx.prune = true + + // prune order : pod3 -> pod2 -> pod1 + syncCtx.resources = groupResources(ReconciliationResult{ + Target: []*unstructured.Unstructured{nil, nil, nil}, + Live: []*unstructured.Unstructured{pod1, pod2, pod3}, + }) + + var phase synccommon.OperationPhase + var msg string + var result []synccommon.ResourceSyncResult + + // 1st sync should prune only pod3 + syncCtx.Sync() + phase, _, result = syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Len(t, result, 1) + assert.Equal(t, "pod-3", result[0].ResourceKey.Name) + assert.Equal(t, synccommon.ResultCodePruned, result[0].Status) + + // simulate successful delete of pod3 + syncCtx.resources = groupResources(ReconciliationResult{ + Target: []*unstructured.Unstructured{nil, nil}, + Live: []*unstructured.Unstructured{pod1, pod2}, + }) + + // next sync should prune only pod2 + syncCtx.Sync() + phase, _, result = syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Len(t, result, 2) + assert.Equal(t, "pod-2", result[1].ResourceKey.Name) + assert.Equal(t, synccommon.ResultCodePruned, result[1].Status) + + // add delete timestamp on pod2 to simulate pending delete + pod2.SetDeletionTimestamp(&metav1.Time{Time: time.Now()}) + + // next sync should wait for deletion of pod2 from cluster, + // it should not move to next wave and prune pod1 + syncCtx.Sync() + phase, msg, result = syncCtx.GetState() + assert.Equal(t, synccommon.OperationRunning, phase) + assert.Equal(t, "waiting for deletion of /Pod/pod-2", msg) + assert.Len(t, result, 2) + + // simulate successful delete of pod2 + syncCtx.resources = groupResources(ReconciliationResult{ + Target: []*unstructured.Unstructured{nil}, + Live: []*unstructured.Unstructured{pod1}, + }) + + // next sync should proceed with next wave + // i.e deletion of pod1 + syncCtx.Sync() + phase, _, result = syncCtx.GetState() + assert.Equal(t, synccommon.OperationSucceeded, phase) + assert.Len(t, result, 3) + assert.Equal(t, "pod-3", result[0].ResourceKey.Name) + assert.Equal(t, "pod-2", result[1].ResourceKey.Name) + assert.Equal(t, "pod-1", result[2].ResourceKey.Name) + assert.Equal(t, synccommon.ResultCodePruned, result[0].Status) + assert.Equal(t, synccommon.ResultCodePruned, result[1].Status) + assert.Equal(t, synccommon.ResultCodePruned, result[2].Status) +} + +func BenchmarkSync(b *testing.B) { + podManifest := `{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": { + "name": "my-pod" + }, + "spec": { + "containers": [ + ${containers} + ] + } + }` + container := `{ + "image": "nginx:1.7.9", + "name": "nginx", + "resources": { + "requests": { + "cpu": "0.2" + } + } + }` + + maxContainers := 10 + for i := 0; i < b.N; i++ { + b.StopTimer() + + containerCount := min(i+1, maxContainers) + + containerStr := strings.Repeat(container+",", containerCount) + containerStr = containerStr[:len(containerStr)-1] + + manifest := strings.ReplaceAll(podManifest, "${containers}", containerStr) + pod := testingutils.Unstructured(manifest) + pod.SetNamespace(testingutils.FakeArgoCDNamespace) + + syncCtx := newTestSyncCtx(nil, WithOperationSettings(false, true, false, false)) + syncCtx.log = logr.Discard() + syncCtx.resources = groupResources(ReconciliationResult{ + Live: []*unstructured.Unstructured{nil, pod}, + Target: []*unstructured.Unstructured{testingutils.NewService(), nil}, + }) + + b.StartTimer() + syncCtx.Sync() + } +} + +func TestNeedsClientSideApplyMigration(t *testing.T) { + syncCtx := newTestSyncCtx(nil) + + tests := []struct { + name string + liveObj *unstructured.Unstructured + expected bool + }{ + { + name: "nil object", + liveObj: nil, + expected: false, + }, + { + name: "object with no managed fields", + liveObj: testingutils.NewPod(), + expected: false, + }, + { + name: "object with kubectl-client-side-apply fields", + liveObj: func() *unstructured.Unstructured { + obj := testingutils.NewPod() + obj.SetManagedFields([]metav1.ManagedFieldsEntry{ + { + Manager: "kubectl-client-side-apply", + Operation: metav1.ManagedFieldsOperationUpdate, + FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:metadata":{"f:annotations":{}}}`)}, + }, + }) + return obj + }(), + expected: true, + }, + { + name: "object with only argocd-controller fields", + liveObj: func() *unstructured.Unstructured { + obj := testingutils.NewPod() + obj.SetManagedFields([]metav1.ManagedFieldsEntry{ + { + Manager: "argocd-controller", + Operation: metav1.ManagedFieldsOperationApply, + FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:spec":{"f:replicas":{}}}`)}, + }, + }) + return obj + }(), + expected: false, + }, + { + name: "object with mixed field managers", + liveObj: func() *unstructured.Unstructured { + obj := testingutils.NewPod() + obj.SetManagedFields([]metav1.ManagedFieldsEntry{ + { + Manager: "kubectl-client-side-apply", + Operation: metav1.ManagedFieldsOperationUpdate, + FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:metadata":{"f:annotations":{}}}`)}, + }, + { + Manager: "argocd-controller", + Operation: metav1.ManagedFieldsOperationApply, + FieldsV1: &metav1.FieldsV1{Raw: []byte(`{"f:spec":{"f:replicas":{}}}`)}, + }, + }) + return obj + }(), + expected: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := syncCtx.needsClientSideApplyMigration(tt.liveObj, "kubectl-client-side-apply") + assert.Equal(t, tt.expected, result) + }) + } +} + +func diffResultListClusterResource() *diff.DiffResultList { + ns1 := testingutils.NewNamespace() + ns1.SetName("ns-1") + ns2 := testingutils.NewNamespace() + ns2.SetName("ns-2") + ns3 := testingutils.NewNamespace() + ns3.SetName("ns-3") + + diffResultList := diff.DiffResultList{ + Modified: true, + Diffs: []diff.DiffResult{}, + } + + nsBytes, _ := json.Marshal(ns1) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: nsBytes, PredictedLive: nsBytes, Modified: false}) + + nsBytes, _ = json.Marshal(ns2) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: nsBytes, PredictedLive: nsBytes, Modified: false}) + + nsBytes, _ = json.Marshal(ns3) + diffResultList.Diffs = append(diffResultList.Diffs, diff.DiffResult{NormalizedLive: nsBytes, PredictedLive: nsBytes, Modified: false}) + + return &diffResultList +} diff --git a/gitops-engine/pkg/sync/sync_phase.go b/gitops-engine/pkg/sync/sync_phase.go new file mode 100644 index 0000000000000..ee0d3cade547e --- /dev/null +++ b/gitops-engine/pkg/sync/sync_phase.go @@ -0,0 +1,28 @@ +package sync + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/sync/hook" +) + +func syncPhases(obj *unstructured.Unstructured) []common.SyncPhase { + if hook.Skip(obj) { + return nil + } else if hook.IsHook(obj) { + phasesMap := make(map[common.SyncPhase]bool) + for _, hookType := range hook.Types(obj) { + switch hookType { + case common.HookTypePreSync, common.HookTypeSync, common.HookTypePostSync, common.HookTypeSyncFail: + phasesMap[common.SyncPhase(hookType)] = true + } + } + var phases []common.SyncPhase + for phase := range phasesMap { + phases = append(phases, phase) + } + return phases + } + return []common.SyncPhase{common.SyncPhaseSync} +} diff --git a/gitops-engine/pkg/sync/sync_phase_test.go b/gitops-engine/pkg/sync/sync_phase_test.go new file mode 100644 index 0000000000000..0945ff6650e52 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_phase_test.go @@ -0,0 +1,57 @@ +package sync + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestSyncPhaseNone(t *testing.T) { + assert.Equal(t, []common.SyncPhase{common.SyncPhaseSync}, syncPhases(&unstructured.Unstructured{})) +} + +func TestSyncPhasePreSync(t *testing.T) { + assert.Equal(t, []common.SyncPhase{common.SyncPhasePreSync}, syncPhases(pod("PreSync"))) +} + +func TestSyncPhaseSync(t *testing.T) { + assert.Equal(t, []common.SyncPhase{common.SyncPhaseSync}, syncPhases(pod("Sync"))) +} + +func TestSyncPhaseSkip(t *testing.T) { + assert.Nil(t, syncPhases(pod("Skip"))) +} + +// garbage hooks are still hooks, but have no phases, because some user spelled something wrong +func TestSyncPhaseGarbage(t *testing.T) { + assert.Nil(t, syncPhases(pod("Garbage"))) +} + +func TestSyncPhasePost(t *testing.T) { + assert.Equal(t, []common.SyncPhase{common.SyncPhasePostSync}, syncPhases(pod("PostSync"))) +} + +func TestSyncPhaseFail(t *testing.T) { + assert.Equal(t, []common.SyncPhase{common.SyncPhaseSyncFail}, syncPhases(pod("SyncFail"))) +} + +func TestSyncPhaseTwoPhases(t *testing.T) { + assert.ElementsMatch(t, []common.SyncPhase{common.SyncPhasePreSync, common.SyncPhasePostSync}, syncPhases(pod("PreSync,PostSync"))) +} + +func TestSyncDuplicatedPhases(t *testing.T) { + assert.ElementsMatch(t, []common.SyncPhase{common.SyncPhasePreSync}, syncPhases(pod("PreSync,PreSync"))) + assert.ElementsMatch(t, []common.SyncPhase{common.SyncPhasePreSync}, syncPhases(podWithHelmHook("pre-install,pre-upgrade"))) +} + +func pod(hookType string) *unstructured.Unstructured { + return testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", hookType) +} + +func podWithHelmHook(hookType string) *unstructured.Unstructured { + return testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook", hookType) +} diff --git a/gitops-engine/pkg/sync/sync_task.go b/gitops-engine/pkg/sync/sync_task.go new file mode 100644 index 0000000000000..81f0c53232549 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_task.go @@ -0,0 +1,164 @@ +package sync + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/sync/hook" + "github.com/argoproj/gitops-engine/pkg/sync/syncwaves" + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +// syncTask holds the live and target object. At least one should be non-nil. A targetObj of nil +// indicates the live object needs to be pruned. A liveObj of nil indicates the object has yet to +// be deployed +type syncTask struct { + phase common.SyncPhase + liveObj *unstructured.Unstructured + targetObj *unstructured.Unstructured + skipDryRun bool + syncStatus common.ResultCode + operationState common.OperationPhase + message string + waveOverride *int +} + +func ternary(val bool, a, b string) string { + if val { + return a + } + return b +} + +func (t *syncTask) String() string { + return fmt.Sprintf("%s/%d %s %s/%s:%s/%s %s->%s (%s,%s,%s)", + t.phase, t.wave(), + ternary(t.isHook(), "hook", "resource"), t.group(), t.kind(), t.namespace(), t.name(), + ternary(t.liveObj != nil, "obj", "nil"), ternary(t.targetObj != nil, "obj", "nil"), + t.syncStatus, t.operationState, t.message, + ) +} + +func (t *syncTask) isPrune() bool { + return t.targetObj == nil +} + +func (t *syncTask) resultKey() string { + return resourceResultKey(kube.GetResourceKey(t.obj()), t.phase) +} + +// return the target object (if this exists) otherwise the live object +// some caution - often you explicitly want the live object not the target object +func (t *syncTask) obj() *unstructured.Unstructured { + return obj(t.targetObj, t.liveObj) +} + +func (t *syncTask) wave() int { + if t.waveOverride != nil { + return *t.waveOverride + } + return syncwaves.Wave(t.obj()) +} + +func (t *syncTask) isHook() bool { + return hook.IsHook(t.obj()) +} + +func (t *syncTask) group() string { + return t.groupVersionKind().Group +} + +func (t *syncTask) kind() string { + return t.groupVersionKind().Kind +} + +func (t *syncTask) version() string { + return t.groupVersionKind().Version +} + +func (t *syncTask) groupVersionKind() schema.GroupVersionKind { + return t.obj().GroupVersionKind() +} + +func (t *syncTask) name() string { + return t.obj().GetName() +} + +func (t *syncTask) namespace() string { + return t.obj().GetNamespace() +} + +func (t *syncTask) pending() bool { + return t.operationState == "" +} + +func (t *syncTask) running() bool { + return t.operationState.Running() +} + +func (t *syncTask) completed() bool { + return t.operationState.Completed() +} + +func (t *syncTask) successful() bool { + return t.operationState.Successful() +} + +func (t *syncTask) pruned() bool { + return t.syncStatus == common.ResultCodePruned +} + +func (t *syncTask) hookType() common.HookType { + if t.isHook() { + return common.HookType(t.phase) + } + return "" +} + +func (t *syncTask) hasHookDeletePolicy(policy common.HookDeletePolicy) bool { + // cannot have a policy if it is not a hook, it is meaningless + if !t.isHook() { + return false + } + for _, p := range hook.DeletePolicies(t.obj()) { + if p == policy { + return true + } + } + return false +} + +func (t *syncTask) deleteBeforeCreation() bool { + return t.liveObj != nil && t.pending() && t.hasHookDeletePolicy(common.HookDeletePolicyBeforeHookCreation) +} + +func (t *syncTask) deleteOnPhaseCompletion() bool { + return t.deleteOnPhaseFailed() || t.deleteOnPhaseSuccessful() +} + +func (t *syncTask) deleteOnPhaseSuccessful() bool { + return t.liveObj != nil && t.hasHookDeletePolicy(common.HookDeletePolicyHookSucceeded) +} + +func (t *syncTask) deleteOnPhaseFailed() bool { + return t.liveObj != nil && t.hasHookDeletePolicy(common.HookDeletePolicyHookFailed) +} + +func (t *syncTask) resourceKey() kube.ResourceKey { + resourceKey := kube.GetResourceKey(t.obj()) + if t.liveObj != nil { + // t.targetObj has a namespace set for cluster-scoped resources, which causes kube.GetResourceKey() + // to produce an incorrect key with the namespace included. For example: + // rbac.authorization.k8s.io/ClusterRole/my-namespace/my-cluster-role + // instead of the correct rbac.authorization.k8s.io/ClusterRole//my-cluster-role. + // To prevent resource lookup issues, we always rely on the namespace of the live object if it is available. + // This logic will work for both cluster scoped and namespace scoped resources. + // + // Refer to https://github.com/argoproj/gitops-engine/blob/8007df5f6c5dd78a1a8cef73569468ce4d83682c/pkg/sync/sync_context.go#L827-L833 + resourceKey.Namespace = t.liveObj.GetNamespace() + } + return resourceKey +} diff --git a/gitops-engine/pkg/sync/sync_task_test.go b/gitops-engine/pkg/sync/sync_task_test.go new file mode 100644 index 0000000000000..16825d0b46a03 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_task_test.go @@ -0,0 +1,75 @@ +package sync + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func newHook(hookType common.HookType) *unstructured.Unstructured { + return testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", string(hookType)) +} + +func Test_syncTask_hookType(t *testing.T) { + type fields struct { + phase common.SyncPhase + liveObj *unstructured.Unstructured + } + tests := []struct { + name string + fields fields + want common.HookType + }{ + {"Empty", fields{common.SyncPhaseSync, testingutils.NewPod()}, ""}, + {"PreSyncHook", fields{common.SyncPhasePreSync, newHook(common.HookTypePreSync)}, common.HookTypePreSync}, + {"SyncHook", fields{common.SyncPhaseSync, newHook(common.HookTypeSync)}, common.HookTypeSync}, + {"PostSyncHook", fields{common.SyncPhasePostSync, newHook(common.HookTypePostSync)}, common.HookTypePostSync}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + task := &syncTask{ + phase: tt.fields.phase, + liveObj: tt.fields.liveObj, + } + hookType := task.hookType() + assert.Equal(t, tt.want, hookType) + }) + } +} + +func Test_syncTask_hasHookDeletePolicy(t *testing.T) { + assert.False(t, (&syncTask{targetObj: testingutils.NewPod()}).hasHookDeletePolicy(common.HookDeletePolicyBeforeHookCreation)) + assert.False(t, (&syncTask{targetObj: testingutils.NewPod()}).hasHookDeletePolicy(common.HookDeletePolicyHookSucceeded)) + assert.False(t, (&syncTask{targetObj: testingutils.NewPod()}).hasHookDeletePolicy(common.HookDeletePolicyHookFailed)) + // must be hook + assert.False(t, (&syncTask{targetObj: testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).hasHookDeletePolicy(common.HookDeletePolicyBeforeHookCreation)) + assert.True(t, (&syncTask{targetObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).hasHookDeletePolicy(common.HookDeletePolicyBeforeHookCreation)) + assert.True(t, (&syncTask{targetObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "HookSucceeded")}).hasHookDeletePolicy(common.HookDeletePolicyHookSucceeded)) + assert.True(t, (&syncTask{targetObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "HookFailed")}).hasHookDeletePolicy(common.HookDeletePolicyHookFailed)) +} + +func Test_syncTask_deleteOnPhaseCompletion(t *testing.T) { + assert.False(t, (&syncTask{liveObj: testingutils.NewPod()}).deleteOnPhaseCompletion()) + // must be hook + assert.True(t, (&syncTask{operationState: common.OperationSucceeded, liveObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "HookSucceeded")}).deleteOnPhaseCompletion()) + assert.True(t, (&syncTask{operationState: common.OperationFailed, liveObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "HookFailed")}).deleteOnPhaseCompletion()) +} + +func Test_syncTask_deleteBeforeCreation(t *testing.T) { + assert.False(t, (&syncTask{liveObj: testingutils.NewPod()}).deleteBeforeCreation()) + // must be hook + assert.False(t, (&syncTask{liveObj: testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).deleteBeforeCreation()) + // no need to delete if no live obj + assert.False(t, (&syncTask{targetObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).deleteBeforeCreation()) + assert.True(t, (&syncTask{liveObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).deleteBeforeCreation()) + assert.True(t, (&syncTask{liveObj: testingutils.Annotate(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/hook", "Sync"), "argocd.argoproj.io/hook-delete-policy", "BeforeHookCreation")}).deleteBeforeCreation()) +} + +func Test_syncTask_wave(t *testing.T) { + assert.Equal(t, 0, (&syncTask{targetObj: testingutils.NewPod()}).wave()) + assert.Equal(t, 1, (&syncTask{targetObj: testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/sync-wave", "1")}).wave()) +} diff --git a/gitops-engine/pkg/sync/sync_tasks.go b/gitops-engine/pkg/sync/sync_tasks.go new file mode 100644 index 0000000000000..813533a231e99 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_tasks.go @@ -0,0 +1,276 @@ +package sync + +import ( + "fmt" + "sort" + "strings" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +// kindOrder represents the correct order of Kubernetes resources within a manifest +var syncPhaseOrder = map[common.SyncPhase]int{ + common.SyncPhasePreSync: -1, + common.SyncPhaseSync: 0, + common.SyncPhasePostSync: 1, + common.SyncPhaseSyncFail: 2, +} + +// kindOrder represents the correct order of Kubernetes resources within a manifest +// https://github.com/helm/helm/blob/0361dc85689e3a6d802c444e2540c92cb5842bc9/pkg/releaseutil/kind_sorter.go +var kindOrder = map[string]int{} + +func init() { + kinds := []string{ + "Namespace", + "NetworkPolicy", + "ResourceQuota", + "LimitRange", + "PodSecurityPolicy", + "PodDisruptionBudget", + "ServiceAccount", + "Secret", + "SecretList", + "ConfigMap", + "StorageClass", + "PersistentVolume", + "PersistentVolumeClaim", + "CustomResourceDefinition", + "ClusterRole", + "ClusterRoleList", + "ClusterRoleBinding", + "ClusterRoleBindingList", + "Role", + "RoleList", + "RoleBinding", + "RoleBindingList", + "Service", + "DaemonSet", + "Pod", + "ReplicationController", + "ReplicaSet", + "Deployment", + "HorizontalPodAutoscaler", + "StatefulSet", + "Job", + "CronJob", + "IngressClass", + "Ingress", + "APIService", + } + for i, kind := range kinds { + // make sure none of the above entries are zero, we need that for custom resources + kindOrder[kind] = i - len(kinds) + } +} + +type syncTasks []*syncTask + +func (s syncTasks) Len() int { + return len(s) +} + +func (s syncTasks) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} + +// order is +// 1. phase +// 2. wave +// 3. kind +// 4. name +func (s syncTasks) Less(i, j int) bool { + tA := s[i] + tB := s[j] + + d := syncPhaseOrder[tA.phase] - syncPhaseOrder[tB.phase] + if d != 0 { + return d < 0 + } + + d = tA.wave() - tB.wave() + if d != 0 { + return d < 0 + } + + a := tA.obj() + b := tB.obj() + + // we take advantage of the fact that if the kind is not in the kindOrder map, + // then it will return the default int value of zero, which is the highest value + d = kindOrder[a.GetKind()] - kindOrder[b.GetKind()] + if d != 0 { + return d < 0 + } + + return a.GetName() < b.GetName() +} + +func (s syncTasks) Sort() { + sort.Sort(s) + // make sure namespaces are created before resources referencing namespaces + s.adjustDeps(func(obj *unstructured.Unstructured) (string, bool) { + return obj.GetName(), obj.GetKind() == kube.NamespaceKind && obj.GroupVersionKind().Group == "" + }, func(obj *unstructured.Unstructured) (string, bool) { + return obj.GetNamespace(), obj.GetNamespace() != "" + }) + // make sure CRDs are created before CRs + s.adjustDeps(func(obj *unstructured.Unstructured) (string, bool) { + if kube.IsCRD(obj) { + crdGroup, ok, err := unstructured.NestedString(obj.Object, "spec", "group") + if err != nil || !ok { + return "", false + } + crdKind, ok, err := unstructured.NestedString(obj.Object, "spec", "names", "kind") + if err != nil || !ok { + return "", false + } + return fmt.Sprintf("%s/%s", crdGroup, crdKind), true + } + return "", false + }, func(obj *unstructured.Unstructured) (string, bool) { + gk := obj.GroupVersionKind() + return fmt.Sprintf("%s/%s", gk.Group, gk.Kind), true + }) +} + +// adjust order of tasks and bubble up tasks which are dependencies of other tasks +// (e.g. namespace sync should happen before resources that resides in that namespace) +func (s syncTasks) adjustDeps(isDep func(obj *unstructured.Unstructured) (string, bool), doesRefDep func(obj *unstructured.Unstructured) (string, bool)) { + // store dependency key and first occurrence of resource referencing the dependency + firstIndexByDepKey := map[string]int{} + + for i, t := range s { + if t.targetObj == nil { + continue + } + + if depKey, ok := isDep(t.targetObj); ok { + // if tasks is a dependency then insert if before first task that reference it + if index, ok := firstIndexByDepKey[depKey]; ok { + // wave and sync phase of dependency resource must be same as wave and phase of resource that depend on it + wave := s[index].wave() + t.waveOverride = &wave + t.phase = s[index].phase + + for j := i; j > index; j-- { + s[j] = s[j-1] + } + s[index] = t + // increase previously collected indexes by 1 + for ns, firstIndex := range firstIndexByDepKey { + if firstIndex >= index { + firstIndexByDepKey[ns] = firstIndex + 1 + } + } + } + } else if depKey, ok := doesRefDep(t.targetObj); ok { + // if task is referencing the dependency then store first index of it + if _, ok := firstIndexByDepKey[depKey]; !ok { + firstIndexByDepKey[depKey] = i + } + } + } +} + +func (s syncTasks) Filter(predicate func(task *syncTask) bool) (tasks syncTasks) { + for _, task := range s { + if predicate(task) { + tasks = append(tasks, task) + } + } + return tasks +} + +func (s syncTasks) Split(predicate func(task *syncTask) bool) (trueTasks, falseTasks syncTasks) { + for _, task := range s { + if predicate(task) { + trueTasks = append(trueTasks, task) + } else { + falseTasks = append(falseTasks, task) + } + } + return trueTasks, falseTasks +} + +func (s syncTasks) Map(predicate func(task *syncTask) string) []string { + messagesMap := make(map[string]any) + for _, task := range s { + messagesMap[predicate(task)] = nil + } + messages := make([]string, 0) + for key := range messagesMap { + messages = append(messages, key) + } + return messages +} + +func (s syncTasks) All(predicate func(task *syncTask) bool) bool { + for _, task := range s { + if !predicate(task) { + return false + } + } + return true +} + +func (s syncTasks) Any(predicate func(task *syncTask) bool) bool { + for _, task := range s { + if predicate(task) { + return true + } + } + return false +} + +func (s syncTasks) Find(predicate func(task *syncTask) bool) *syncTask { + for _, task := range s { + if predicate(task) { + return task + } + } + return nil +} + +func (s syncTasks) String() string { + var values []string + for _, task := range s { + values = append(values, task.String()) + } + return "[" + strings.Join(values, ", ") + "]" +} + +func (s syncTasks) phase() common.SyncPhase { + if len(s) > 0 { + return s[0].phase + } + return "" +} + +func (s syncTasks) wave() int { + if len(s) > 0 { + return s[0].wave() + } + return 0 +} + +func (s syncTasks) lastPhase() common.SyncPhase { + if len(s) > 0 { + return s[len(s)-1].phase + } + return "" +} + +func (s syncTasks) lastWave() int { + if len(s) > 0 { + return s[len(s)-1].wave() + } + return 0 +} + +func (s syncTasks) multiStep() bool { + return s.wave() != s.lastWave() || s.phase() != s.lastPhase() +} diff --git a/gitops-engine/pkg/sync/sync_tasks_test.go b/gitops-engine/pkg/sync/sync_tasks_test.go new file mode 100644 index 0000000000000..18135beab2fd0 --- /dev/null +++ b/gitops-engine/pkg/sync/sync_tasks_test.go @@ -0,0 +1,484 @@ +package sync + +import ( + "sort" + "testing" + + "github.com/stretchr/testify/assert" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func Test_syncTasks_kindOrder(t *testing.T) { + assert.Equal(t, -35, kindOrder["Namespace"]) + assert.Equal(t, -1, kindOrder["APIService"]) + assert.Equal(t, 0, kindOrder["MyCRD"]) +} + +func TestSortSyncTask(t *testing.T) { + sort.Sort(unsortedTasks) + assert.Equal(t, sortedTasks, unsortedTasks) +} + +func TestAnySyncTasks(t *testing.T) { + res := unsortedTasks.Any(func(task *syncTask) bool { + return task.name() == "a" + }) + assert.True(t, res) + + res = unsortedTasks.Any(func(task *syncTask) bool { + return task.name() == "does-not-exist" + }) + assert.False(t, res) +} + +func TestAllSyncTasks(t *testing.T) { + res := unsortedTasks.All(func(task *syncTask) bool { + return task.name() != "" + }) + assert.False(t, res) + + res = unsortedTasks.All(func(task *syncTask) bool { + return task.name() == "a" + }) + assert.False(t, res) +} + +func TestSplitSyncTasks(t *testing.T) { + named, unnamed := sortedTasks.Split(func(task *syncTask) bool { + return task.name() != "" + }) + assert.Equal(t, named, namedObjTasks) + assert.Equal(t, unnamed, unnamedTasks) +} + +var unsortedTasks = syncTasks{ + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Pod", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Service", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "PersistentVolume", + }, + }, + }, + { + phase: common.SyncPhaseSyncFail, targetObj: &unstructured.Unstructured{}, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "1", + }, + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "b", + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "a", + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "-1", + }, + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + }, + }, + }, + { + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{}, + }, + { + phase: common.SyncPhasePostSync, targetObj: &unstructured.Unstructured{}, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "ConfigMap", + }, + }, + }, +} + +var sortedTasks = syncTasks{ + { + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{}, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "-1", + }, + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "ConfigMap", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "PersistentVolume", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Service", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Pod", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "a", + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "b", + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "1", + }, + }, + }, + }, + }, + { + phase: common.SyncPhasePostSync, + targetObj: &unstructured.Unstructured{}, + }, + { + phase: common.SyncPhaseSyncFail, + targetObj: &unstructured.Unstructured{}, + }, +} + +var namedObjTasks = syncTasks{ + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "a", + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "b", + }, + }, + }, + }, +} + +var unnamedTasks = syncTasks{ + { + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{}, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "-1", + }, + }, + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "ConfigMap", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "PersistentVolume", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Service", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + "kind": "Pod", + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "GroupVersion": corev1.SchemeGroupVersion.String(), + }, + }, + }, + { + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "annotations": map[string]any{ + "argocd.argoproj.io/sync-wave": "1", + }, + }, + }, + }, + }, + { + phase: common.SyncPhasePostSync, + targetObj: &unstructured.Unstructured{}, + }, + { + phase: common.SyncPhaseSyncFail, + targetObj: &unstructured.Unstructured{}, + }, +} + +func Test_syncTasks_Filter(t *testing.T) { + tasks := syncTasks{{phase: common.SyncPhaseSync}, {phase: common.SyncPhasePostSync}} + + assert.Equal(t, syncTasks{{phase: common.SyncPhaseSync}}, tasks.Filter(func(t *syncTask) bool { + return t.phase == common.SyncPhaseSync + })) +} + +func TestSyncNamespaceAgainstCRD(t *testing.T) { + crd := &syncTask{ + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Workflow", + }, + }, + } + namespace := &syncTask{ + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Namespace", + }, + }, + } + + unsorted := syncTasks{crd, namespace} + sort.Sort(unsorted) + + assert.Equal(t, syncTasks{namespace, crd}, unsorted) +} + +func TestSyncTasksSort_NamespaceAndObjectInNamespace(t *testing.T) { + hook1 := &syncTask{ + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Job", + "metadata": map[string]any{ + "namespace": "myNamespace1", + "name": "mySyncHookJob1", + }, + }, + }, + } + hook2 := &syncTask{ + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Job", + "metadata": map[string]any{ + "namespace": "myNamespace2", + "name": "mySyncHookJob2", + }, + }, + }, + } + namespace1 := &syncTask{ + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Namespace", + "metadata": map[string]any{ + "name": "myNamespace1", + "annotations": map[string]string{ + "argocd.argoproj.io/sync-wave": "1", + }, + }, + }, + }, + } + namespace2 := &syncTask{ + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Namespace", + "metadata": map[string]any{ + "name": "myNamespace2", + "annotations": map[string]string{ + "argocd.argoproj.io/sync-wave": "2", + }, + }, + }, + }, + } + + unsorted := syncTasks{hook1, hook2, namespace1, namespace2} + unsorted.Sort() + + assert.Equal(t, syncTasks{namespace1, hook1, namespace2, hook2}, unsorted) + assert.Equal(t, 0, namespace1.wave()) + assert.Equal(t, common.SyncPhase(common.SyncPhasePreSync), namespace1.phase) + assert.Equal(t, 0, namespace2.wave()) + assert.Equal(t, common.SyncPhase(common.SyncPhasePreSync), namespace2.phase) +} + +func TestSyncTasksSort_CRDAndCR(t *testing.T) { + cr := &syncTask{ + phase: common.SyncPhasePreSync, + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "kind": "Workflow", + "apiVersion": "argoproj.io/v1", + }, + }, + } + crd := &syncTask{ + targetObj: &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "apiextensions.k8s.io/v1", + "kind": "CustomResourceDefinition", + "spec": map[string]any{ + "group": "argoproj.io", + "names": map[string]any{ + "kind": "Workflow", + }, + }, + }, + }, + } + + unsorted := syncTasks{cr, crd} + unsorted.Sort() + + assert.Equal(t, syncTasks{crd, cr}, unsorted) +} + +func Test_syncTasks_multiStep(t *testing.T) { + t.Run("Single", func(t *testing.T) { + tasks := syncTasks{{liveObj: testingutils.Annotate(testingutils.NewPod(), common.AnnotationSyncWave, "-1"), phase: common.SyncPhaseSync}} + assert.Equal(t, common.SyncPhaseSync, string(tasks.phase())) + assert.Equal(t, -1, tasks.wave()) + assert.Equal(t, common.SyncPhaseSync, string(tasks.lastPhase())) + assert.Equal(t, -1, tasks.lastWave()) + assert.False(t, tasks.multiStep()) + }) + t.Run("Double", func(t *testing.T) { + tasks := syncTasks{ + {liveObj: testingutils.Annotate(testingutils.NewPod(), common.AnnotationSyncWave, "-1"), phase: common.SyncPhasePreSync}, + {liveObj: testingutils.Annotate(testingutils.NewPod(), common.AnnotationSyncWave, "1"), phase: common.SyncPhasePostSync}, + } + assert.Equal(t, common.SyncPhasePreSync, string(tasks.phase())) + assert.Equal(t, -1, tasks.wave()) + assert.Equal(t, common.SyncPhasePostSync, string(tasks.lastPhase())) + assert.Equal(t, 1, tasks.lastWave()) + assert.True(t, tasks.multiStep()) + }) +} diff --git a/gitops-engine/pkg/sync/syncwaves/waves.go b/gitops-engine/pkg/sync/syncwaves/waves.go new file mode 100644 index 0000000000000..200433571449b --- /dev/null +++ b/gitops-engine/pkg/sync/syncwaves/waves.go @@ -0,0 +1,21 @@ +package syncwaves + +import ( + "strconv" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + "github.com/argoproj/gitops-engine/pkg/sync/common" + helmhook "github.com/argoproj/gitops-engine/pkg/sync/hook/helm" +) + +func Wave(obj *unstructured.Unstructured) int { + text, ok := obj.GetAnnotations()[common.AnnotationSyncWave] + if ok { + val, err := strconv.Atoi(text) + if err == nil { + return val + } + } + return helmhook.Weight(obj) +} diff --git a/gitops-engine/pkg/sync/syncwaves/waves_test.go b/gitops-engine/pkg/sync/syncwaves/waves_test.go new file mode 100644 index 0000000000000..2fadf4fd7d264 --- /dev/null +++ b/gitops-engine/pkg/sync/syncwaves/waves_test.go @@ -0,0 +1,15 @@ +package syncwaves + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" +) + +func TestWave(t *testing.T) { + assert.Equal(t, 0, Wave(testingutils.NewPod())) + assert.Equal(t, 1, Wave(testingutils.Annotate(testingutils.NewPod(), "argocd.argoproj.io/sync-wave", "1"))) + assert.Equal(t, 1, Wave(testingutils.Annotate(testingutils.NewPod(), "helm.sh/hook-weight", "1"))) +} diff --git a/gitops-engine/pkg/utils/io/io.go b/gitops-engine/pkg/utils/io/io.go new file mode 100644 index 0000000000000..6f07bb192c9f6 --- /dev/null +++ b/gitops-engine/pkg/utils/io/io.go @@ -0,0 +1,23 @@ +package io + +import ( + "os" +) + +// TempDir is set to '/dev/shm' if exists, otherwise is "", which defaults to os.TempDir() when passed to os.CreateTemp() +var TempDir string + +func init() { + fileInfo, err := os.Stat("/dev/shm") + if err == nil && fileInfo.IsDir() { + TempDir = "/dev/shm" + } +} + +// DeleteFile is best effort deletion of a file +func DeleteFile(path string) { + if _, err := os.Stat(path); os.IsNotExist(err) { + return + } + _ = os.Remove(path) +} diff --git a/gitops-engine/pkg/utils/json/json.go b/gitops-engine/pkg/utils/json/json.go new file mode 100644 index 0000000000000..4cb2f8ed03085 --- /dev/null +++ b/gitops-engine/pkg/utils/json/json.go @@ -0,0 +1,54 @@ +package json + +// https://github.com/ksonnet/ksonnet/blob/master/pkg/kubecfg/diff.go +func removeFields(config, live any) any { + switch c := config.(type) { + case map[string]any: + l, ok := live.(map[string]any) + if ok { + return RemoveMapFields(c, l) + } + return live + case []any: + l, ok := live.([]any) + if ok { + return RemoveListFields(c, l) + } + return live + default: + return live + } +} + +// RemoveMapFields remove all non-existent fields in the live that don't exist in the config +func RemoveMapFields(config, live map[string]any) map[string]any { + result := map[string]any{} + for k, v1 := range config { + v2, ok := live[k] + if !ok { + continue + } + if v2 != nil { + v2 = removeFields(v1, v2) + } + result[k] = v2 + } + return result +} + +func RemoveListFields(config, live []any) []any { + // If live is longer than config, then the extra elements at the end of the + // list will be returned as-is so they appear in the diff. + result := make([]any, 0, len(live)) + for i, v2 := range live { + if len(config) > i { + if v2 != nil { + v2 = removeFields(config[i], v2) + } + result = append(result, v2) + } else { + result = append(result, v2) + } + } + return result +} diff --git a/gitops-engine/pkg/utils/kube/convert.go b/gitops-engine/pkg/utils/kube/convert.go new file mode 100644 index 0000000000000..eb07fd35b9d22 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/convert.go @@ -0,0 +1,28 @@ +package kube + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/argoproj/gitops-engine/pkg/utils/kube/scheme" +) + +func convertToVersionWithScheme(obj *unstructured.Unstructured, group string, version string) (*unstructured.Unstructured, error) { + s := scheme.Scheme + object, err := s.ConvertToVersion(obj, runtime.InternalGroupVersioner) + if err != nil { + return nil, fmt.Errorf("failed to convert to version using internal group versioner: %w", err) + } + unmarshalledObj, err := s.ConvertToVersion(object, schema.GroupVersion{Group: group, Version: version}) + if err != nil { + return nil, fmt.Errorf("failed to convert to version: %w", err) + } + unstrBody, err := runtime.DefaultUnstructuredConverter.ToUnstructured(unmarshalledObj) + if err != nil { + return nil, fmt.Errorf("failed to convert to unstructured object: %w", err) + } + return &unstructured.Unstructured{Object: unstrBody}, nil +} diff --git a/gitops-engine/pkg/utils/kube/convert_test.go b/gitops-engine/pkg/utils/kube/convert_test.go new file mode 100644 index 0000000000000..43e6ebe38cc78 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/convert_test.go @@ -0,0 +1,94 @@ +package kube + +import ( + "testing" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/yaml" +) + +type testcase struct { + name string + file string + outputVersion string + fields []checkField +} + +type checkField struct { + expected string +} + +func Test_convertToVersionWithScheme(t *testing.T) { + for _, tt := range []testcase{ + { + name: "apps deployment to extensions deployment", + file: "appsdeployment.yaml", + outputVersion: "extensions/v1beta1", + fields: []checkField{ + { + expected: "apiVersion: extensions/v1beta1", + }, + }, + }, + { + name: "extensions deployment to apps deployment", + file: "extensionsdeployment.yaml", + outputVersion: "apps/v1beta2", + fields: []checkField{ + { + expected: "apiVersion: apps/v1beta2", + }, + }, + }, + { + name: "v1 HPA to v2beta1 HPA", + file: "v1HPA.yaml", + outputVersion: "autoscaling/v2beta1", + fields: []checkField{ + { + expected: "apiVersion: autoscaling/v2beta1", + }, + { + expected: "name: cpu", + }, + { + expected: "targetAverageUtilization: 50", + }, + }, + }, + { + name: "v2beta1 HPA to v1 HPA", + file: "v2beta1HPA.yaml", + outputVersion: "autoscaling/v1", + fields: []checkField{ + { + expected: "apiVersion: autoscaling/v1", + }, + { + expected: "targetCPUUtilizationPercentage: 50", + }, + }, + }, + } { + t.Run(tt.name, func(t *testing.T) { + obj := testingutils.UnstructuredFromFile("testdata/" + tt.file) + target, err := schema.ParseGroupVersion(tt.outputVersion) + require.NoError(t, err) + out, err := convertToVersionWithScheme(obj, target.Group, target.Version) + if assert.NoError(t, err) { + assert.NotNil(t, out) + assert.Equal(t, target.Group, out.GroupVersionKind().Group) + assert.Equal(t, target.Version, out.GroupVersionKind().Version) + bytes, err := yaml.Marshal(out) + assert.NoError(t, err) + for _, field := range tt.fields { + assert.Contains(t, string(bytes), field.expected) + } + } + }) + } +} diff --git a/gitops-engine/pkg/utils/kube/ctl.go b/gitops-engine/pkg/utils/kube/ctl.go new file mode 100644 index 0000000000000..33bf7c3757d91 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/ctl.go @@ -0,0 +1,381 @@ +package kube + +import ( + "context" + "fmt" + "os" + "strings" + + "github.com/go-logr/logr" + "golang.org/x/sync/errgroup" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/client-go/discovery" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" + "k8s.io/kube-openapi/pkg/util/proto" + "k8s.io/kubectl/pkg/util/openapi" + + "github.com/argoproj/gitops-engine/pkg/diff" + utils "github.com/argoproj/gitops-engine/pkg/utils/io" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +type CleanupFunc func() + +type OnKubectlRunFunc func(command string) (CleanupFunc, error) + +type Kubectl interface { + ManageResources(config *rest.Config, openAPISchema openapi.Resources) (ResourceOperations, func(), error) + LoadOpenAPISchema(config *rest.Config) (openapi.Resources, *managedfields.GvkParser, error) + ConvertToVersion(obj *unstructured.Unstructured, group, version string) (*unstructured.Unstructured, error) + DeleteResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, deleteOptions metav1.DeleteOptions) error + GetResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error) + CreateResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, obj *unstructured.Unstructured, createOptions metav1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error) + PatchResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, patchType types.PatchType, patchBytes []byte, subresources ...string) (*unstructured.Unstructured, error) + GetAPIResources(config *rest.Config, preferred bool, resourceFilter ResourceFilter) ([]APIResourceInfo, error) + GetServerVersion(config *rest.Config) (string, error) + NewDynamicClient(config *rest.Config) (dynamic.Interface, error) + SetOnKubectlRun(onKubectlRun OnKubectlRunFunc) +} + +type KubectlCmd struct { + Log logr.Logger + Tracer tracing.Tracer + OnKubectlRun OnKubectlRunFunc +} + +type APIResourceInfo struct { + GroupKind schema.GroupKind + Meta metav1.APIResource + GroupVersionResource schema.GroupVersionResource +} + +type filterFunc func(apiResource *metav1.APIResource) bool + +func (k *KubectlCmd) filterAPIResources(config *rest.Config, preferred bool, resourceFilter ResourceFilter, filter filterFunc) ([]APIResourceInfo, error) { + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create discovery client: %w", err) + } + + var serverResources []*metav1.APIResourceList + if preferred { + serverResources, err = disco.ServerPreferredResources() + } else { + _, serverResources, err = disco.ServerGroupsAndResources() + } + + if err != nil { + if len(serverResources) == 0 { + return nil, fmt.Errorf("failed to discover server resources, zero resources returned: %w", err) + } + k.Log.Error(err, "Partial success when performing preferred resource discovery") + } + apiResIfs := make([]APIResourceInfo, 0) + for _, apiResourcesList := range serverResources { + gv, err := schema.ParseGroupVersion(apiResourcesList.GroupVersion) + if err != nil { + gv = schema.GroupVersion{} + } + for _, apiResource := range apiResourcesList.APIResources { + if resourceFilter.IsExcludedResource(gv.Group, apiResource.Kind, config.Host) { + continue + } + + if filter(&apiResource) { + resource := ToGroupVersionResource(apiResourcesList.GroupVersion, &apiResource) + gv, err := schema.ParseGroupVersion(apiResourcesList.GroupVersion) + if err != nil { + return nil, fmt.Errorf("failed to parse group version %q: %w", apiResourcesList.GroupVersion, err) + } + apiResIf := APIResourceInfo{ + GroupKind: schema.GroupKind{Group: gv.Group, Kind: apiResource.Kind}, + Meta: apiResource, + GroupVersionResource: resource, + } + apiResIfs = append(apiResIfs, apiResIf) + } + } + } + return apiResIfs, nil +} + +// isSupportedVerb returns whether or not a APIResource supports a specific verb. +// The verb will be matched case-insensitive. +func isSupportedVerb(apiResource *metav1.APIResource, verb string) bool { + if verb == "" || verb == "*" { + return true + } + for _, v := range apiResource.Verbs { + if strings.EqualFold(v, verb) { + return true + } + } + return false +} + +// LoadOpenAPISchema will load all existing resource schemas from the cluster +// and return: +// - openapi.Resources: used for getting the proto.Schema from a GVK +// - managedfields.GvkParser: used for building a ParseableType to be used in +// structured-merge-diffs +func (k *KubectlCmd) LoadOpenAPISchema(config *rest.Config) (openapi.Resources, *managedfields.GvkParser, error) { + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return nil, nil, fmt.Errorf("failed to create discovery client: %w", err) + } + + oapiGetter := openapi.NewOpenAPIGetter(disco) + oapiResources, err := openapi.NewOpenAPIParser(oapiGetter).Parse() + if err != nil { + return nil, nil, fmt.Errorf("error getting openapi resources: %w", err) + } + gvkParser, err := k.newGVKParser(oapiGetter) + if err != nil { + return oapiResources, nil, fmt.Errorf("error getting gvk parser: %w", err) + } + return oapiResources, gvkParser, nil +} + +func (k *KubectlCmd) newGVKParser(oapiGetter discovery.OpenAPISchemaInterface) (*managedfields.GvkParser, error) { + doc, err := oapiGetter.OpenAPISchema() + if err != nil { + return nil, fmt.Errorf("error getting openapi schema: %w", err) + } + models, err := proto.NewOpenAPIData(doc) + if err != nil { + return nil, fmt.Errorf("error getting openapi data: %w", err) + } + var taintedGVKs []schema.GroupVersionKind + models, taintedGVKs = newUniqueModels(models) + if len(taintedGVKs) > 0 { + k.Log.Info("Duplicate GVKs detected in OpenAPI schema. This could cause inaccurate diffs.", "gvks", taintedGVKs) + } + gvkParser, err := managedfields.NewGVKParser(models, false) + if err != nil { + return nil, fmt.Errorf("failed to create GVK parser: %w", err) + } + return gvkParser, nil +} + +func (k *KubectlCmd) GetAPIResources(config *rest.Config, preferred bool, resourceFilter ResourceFilter) ([]APIResourceInfo, error) { + span := k.Tracer.StartSpan("GetAPIResources") + defer span.Finish() + apiResIfs, err := k.filterAPIResources(config, preferred, resourceFilter, func(apiResource *metav1.APIResource) bool { + return isSupportedVerb(apiResource, listVerb) && isSupportedVerb(apiResource, watchVerb) + }) + if err != nil { + return nil, err + } + return apiResIfs, err +} + +// GetResource returns resource +func (k *KubectlCmd) GetResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error) { + span := k.Tracer.StartSpan("GetResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", name) + defer span.Finish() + dynamicIf, err := dynamic.NewForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create dynamic client: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create discovery client: %w", err) + } + apiResource, err := ServerResourceForGroupVersionKind(disco, gvk, "get") + if err != nil { + return nil, fmt.Errorf("failed to get api resource: %w", err) + } + resource := gvk.GroupVersion().WithResource(apiResource.Name) + resourceIf := ToResourceInterface(dynamicIf, apiResource, resource, namespace) + //nolint:wrapcheck // wrapped message would be same as calling method's wrapped error + return resourceIf.Get(ctx, name, metav1.GetOptions{}) +} + +// CreateResource creates resource +func (k *KubectlCmd) CreateResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, obj *unstructured.Unstructured, createOptions metav1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error) { + span := k.Tracer.StartSpan("CreateResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", name) + defer span.Finish() + dynamicIf, err := dynamic.NewForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create dynamic client: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create discovery client: %w", err) + } + apiResource, err := ServerResourceForGroupVersionKind(disco, gvk, "create") + if err != nil { + return nil, fmt.Errorf("failed to get api resource: %w", err) + } + resource := gvk.GroupVersion().WithResource(apiResource.Name) + resourceIf := ToResourceInterface(dynamicIf, apiResource, resource, namespace) + //nolint:wrapcheck // wrapped message would be same as calling method's wrapped error + return resourceIf.Create(ctx, obj, createOptions, subresources...) +} + +// PatchResource patches resource +func (k *KubectlCmd) PatchResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, patchType types.PatchType, patchBytes []byte, subresources ...string) (*unstructured.Unstructured, error) { + span := k.Tracer.StartSpan("PatchResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", name) + defer span.Finish() + dynamicIf, err := dynamic.NewForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create dynamic client: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create discovery client: %w", err) + } + apiResource, err := ServerResourceForGroupVersionKind(disco, gvk, "patch") + if err != nil { + return nil, fmt.Errorf("failed to get api resource: %w", err) + } + resource := gvk.GroupVersion().WithResource(apiResource.Name) + resourceIf := ToResourceInterface(dynamicIf, apiResource, resource, namespace) + //nolint:wrapcheck // wrapped message would be same as calling method's wrapped error + return resourceIf.Patch(ctx, name, patchType, patchBytes, metav1.PatchOptions{}, subresources...) +} + +// DeleteResource deletes resource +func (k *KubectlCmd) DeleteResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string, deleteOptions metav1.DeleteOptions) error { + span := k.Tracer.StartSpan("DeleteResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", name) + defer span.Finish() + dynamicIf, err := dynamic.NewForConfig(config) + if err != nil { + return fmt.Errorf("failed to create dynamic client: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return fmt.Errorf("failed to create discovery client: %w", err) + } + apiResource, err := ServerResourceForGroupVersionKind(disco, gvk, "delete") + if err != nil { + return fmt.Errorf("failed to get api resource: %w", err) + } + resource := gvk.GroupVersion().WithResource(apiResource.Name) + resourceIf := ToResourceInterface(dynamicIf, apiResource, resource, namespace) + + if deleteOptions.PropagationPolicy == nil { + propagationPolicy := metav1.DeletePropagationForeground + deleteOptions = metav1.DeleteOptions{PropagationPolicy: &propagationPolicy} + } + //nolint:wrapcheck // wrapped message would be same as calling method's wrapped error + return resourceIf.Delete(ctx, name, deleteOptions) +} + +func (k *KubectlCmd) ManageResources(config *rest.Config, openAPISchema openapi.Resources) (ResourceOperations, func(), error) { + f, err := os.CreateTemp(utils.TempDir, "") + if err != nil { + return nil, nil, fmt.Errorf("failed to generate temp file for kubeconfig: %w", err) + } + _ = f.Close() + err = WriteKubeConfig(config, "", f.Name()) + if err != nil { + utils.DeleteFile(f.Name()) + return nil, nil, fmt.Errorf("failed to write kubeconfig: %w", err) + } + fact := kubeCmdFactory(f.Name(), "", config) + cleanup := func() { + utils.DeleteFile(f.Name()) + } + return &kubectlResourceOperations{ + config: config, + fact: fact, + openAPISchema: openAPISchema, + tracer: k.Tracer, + log: k.Log, + onKubectlRun: k.OnKubectlRun, + }, cleanup, nil +} + +func ManageServerSideDiffDryRuns(config *rest.Config, openAPISchema openapi.Resources, tracer tracing.Tracer, log logr.Logger, onKubectlRun OnKubectlRunFunc) (diff.KubeApplier, func(), error) { + f, err := os.CreateTemp(utils.TempDir, "") + if err != nil { + return nil, nil, fmt.Errorf("failed to generate temp file for kubeconfig: %w", err) + } + _ = f.Close() + err = WriteKubeConfig(config, "", f.Name()) + if err != nil { + utils.DeleteFile(f.Name()) + return nil, nil, fmt.Errorf("failed to write kubeconfig: %w", err) + } + fact := kubeCmdFactory(f.Name(), "", config) + cleanup := func() { + utils.DeleteFile(f.Name()) + } + return &kubectlServerSideDiffDryRunApplier{ + config: config, + fact: fact, + openAPISchema: openAPISchema, + tracer: tracer, + log: log, + onKubectlRun: onKubectlRun, + }, cleanup, nil +} + +// ConvertToVersion converts an unstructured object into the specified group/version +func (k *KubectlCmd) ConvertToVersion(obj *unstructured.Unstructured, group string, version string) (*unstructured.Unstructured, error) { + span := k.Tracer.StartSpan("ConvertToVersion") + from := obj.GroupVersionKind().GroupVersion() + span.SetBaggageItem("from", from.String()) + span.SetBaggageItem("to", schema.GroupVersion{Group: group, Version: version}.String()) + defer span.Finish() + if from.Group == group && from.Version == version { + return obj.DeepCopy(), nil + } + return convertToVersionWithScheme(obj, group, version) +} + +func (k *KubectlCmd) GetServerVersion(config *rest.Config) (string, error) { + span := k.Tracer.StartSpan("GetServerVersion") + defer span.Finish() + client, err := discovery.NewDiscoveryClientForConfig(config) + if err != nil { + return "", fmt.Errorf("failed to create discovery client: %w", err) + } + v, err := client.ServerVersion() + if err != nil { + return "", fmt.Errorf("failed to get server version: %w", err) + } + return fmt.Sprintf("%s.%s", v.Major, v.Minor), nil +} + +func (k *KubectlCmd) NewDynamicClient(config *rest.Config) (dynamic.Interface, error) { + //nolint:wrapcheck // wrapped error message would be the same as the caller's wrapped message + return dynamic.NewForConfig(config) +} + +func (k *KubectlCmd) SetOnKubectlRun(onKubectlRun OnKubectlRunFunc) { + k.OnKubectlRun = onKubectlRun +} + +func RunAllAsync(count int, action func(i int) error) error { + g, ctx := errgroup.WithContext(context.Background()) +loop: + for i := 0; i < count; i++ { + index := i + g.Go(func() error { + return action(index) + }) + select { + case <-ctx.Done(): + // Something went wrong already, stop spawning tasks. + break loop + default: + } + } + //nolint:wrapcheck // don't wrap message from utility function + return g.Wait() +} diff --git a/gitops-engine/pkg/utils/kube/ctl_test.go b/gitops-engine/pkg/utils/kube/ctl_test.go new file mode 100644 index 0000000000000..11bb6c786cf76 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/ctl_test.go @@ -0,0 +1,110 @@ +package kube + +import ( + _ "embed" + "encoding/json" + "fmt" + "testing" + + openapi_v2 "github.com/google/gnostic-models/openapiv2" + "github.com/stretchr/testify/require" + + "github.com/stretchr/testify/assert" + "k8s.io/klog/v2/textlogger" + + testingutils "github.com/argoproj/gitops-engine/pkg/utils/testing" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +var _ Kubectl = &KubectlCmd{} + +func TestConvertToVersion(t *testing.T) { + kubectl := KubectlCmd{ + Log: textlogger.NewLogger(textlogger.NewConfig()), + Tracer: tracing.NopTracer{}, + } + t.Run("AppsDeployment", func(t *testing.T) { + newObj, err := kubectl.ConvertToVersion(testingutils.UnstructuredFromFile("testdata/appsdeployment.yaml"), "apps", "v1") + if assert.NoError(t, err) { + gvk := newObj.GroupVersionKind() + assert.Equal(t, "apps", gvk.Group) + assert.Equal(t, "v1", gvk.Version) + } + }) + t.Run("CustomResource", func(t *testing.T) { + _, err := kubectl.ConvertToVersion(testingutils.UnstructuredFromFile("testdata/cr.yaml"), "argoproj.io", "v1") + assert.Error(t, err) + }) + t.Run("ExtensionsDeployment", func(t *testing.T) { + obj := testingutils.UnstructuredFromFile("testdata/nginx.yaml") + + // convert an extensions/v1beta1 object into itself + newObj, err := kubectl.ConvertToVersion(obj, "extensions", "v1beta1") + if assert.NoError(t, err) { + gvk := newObj.GroupVersionKind() + assert.Equal(t, "extensions", gvk.Group) + assert.Equal(t, "v1beta1", gvk.Version) + } + + // convert an extensions/v1beta1 object into an apps/v1 + newObj, err = kubectl.ConvertToVersion(obj, "apps", "v1") + if assert.NoError(t, err) { + gvk := newObj.GroupVersionKind() + assert.Equal(t, "apps", gvk.Group) + assert.Equal(t, "v1", gvk.Version) + } + + // converting it again should not have any affect + newObj, err = kubectl.ConvertToVersion(obj, "apps", "v1") + if assert.NoError(t, err) { + gvk := newObj.GroupVersionKind() + assert.Equal(t, "apps", gvk.Group) + assert.Equal(t, "v1", gvk.Version) + } + }) + t.Run("newGVKParser gracefully handles duplicate GVKs", func(t *testing.T) { + client := &fakeOpenAPIClient{} + _, err := kubectl.newGVKParser(client) + require.NoError(t, err) + }) +} + +/** +Getting the test data here was challenging. + +First I needed a Kubernetes cluster with an aggregated API installed which had disagreeing versions of the same +resource. In this case, I used Kubernetes 1.30.1 and metrics-server 0.7.1. They have different versions of +APIResourceList. + +So then I got the protobuf representation of the aggregated OpenAPI doc. I used the following command to get it: +curl -k https://localhost:6443/openapi/v2 -H "Authorization: Bearer $token" -H "Accept: application/com.github.proto-openapi.spec.v2@v1.0+protobuf" > pkg/utils/kube/testdata/openapi_v2.proto + +Then I unmarshaled the protobuf representation into JSON using the following code: + +json.Unmarshal(openAPIDoc, document) +jsondata, _ := json.Marshal(document) +ioutil.WriteFile("pkg/utils/kube/testdata/openapi_v2.json", jsondata, 0644) + +This step was necessary because it's not possible to unmarshal the json representation of the OpenAPI doc into the +openapi_v2.Document struct. I don't know why they're different. + +Then I used this code to post-process the JSON representation of the OpenAPI doc and remove unnecessary information: +jq '.definitions.additional_properties |= map(select(.name | test(".*APIResource.*"))) | {definitions: {additional_properties: .definitions.additional_properties}}' pkg/utils/kube/testdata/openapi_v2.json > pkg/utils/kube/testdata/openapi_v2.json.better +mv pkg/utils/kube/testdata/openapi_v2.json.better pkg/utils/kube/testdata/openapi_v2.json + +Hopefully we'll never need to reload the test data, because it was to demonstrate a very specific bug. +*/ + +//go:embed testdata/openapi_v2.json +var openAPIDoc []byte + +type fakeOpenAPIClient struct{} + +func (f *fakeOpenAPIClient) OpenAPISchema() (*openapi_v2.Document, error) { + document := &openapi_v2.Document{} + err := json.Unmarshal(openAPIDoc, document) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal OpenAPI document: %w", err) + } + return document, nil +} diff --git a/gitops-engine/pkg/utils/kube/kube.go b/gitops-engine/pkg/utils/kube/kube.go new file mode 100644 index 0000000000000..4458fe2f827fe --- /dev/null +++ b/gitops-engine/pkg/utils/kube/kube.go @@ -0,0 +1,471 @@ +// Package kube provides helper utilities common for kubernetes +package kube + +import ( + "bytes" + "context" + "errors" + "fmt" + "io" + "regexp" + "strings" + "time" + + "github.com/go-logr/logr" + + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/equality" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/wait" + kubeyaml "k8s.io/apimachinery/pkg/util/yaml" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/discovery" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/clientcmd" + clientcmdapi "k8s.io/client-go/tools/clientcmd/api" + "sigs.k8s.io/yaml" +) + +const ( + listVerb = "list" + watchVerb = "watch" +) + +const ( + SecretKind = "Secret" + ServiceKind = "Service" + ServiceAccountKind = "ServiceAccount" + EndpointsKind = "Endpoints" + DeploymentKind = "Deployment" + ReplicaSetKind = "ReplicaSet" + StatefulSetKind = "StatefulSet" + DaemonSetKind = "DaemonSet" + IngressKind = "Ingress" + JobKind = "Job" + PersistentVolumeClaimKind = "PersistentVolumeClaim" + CustomResourceDefinitionKind = "CustomResourceDefinition" + PodKind = "Pod" + APIServiceKind = "APIService" + NamespaceKind = "Namespace" + HorizontalPodAutoscalerKind = "HorizontalPodAutoscaler" +) + +type ResourceInfoProvider interface { + IsNamespaced(gk schema.GroupKind) (bool, error) +} + +func IsNamespacedOrUnknown(provider ResourceInfoProvider, gk schema.GroupKind) bool { + namespaced, err := provider.IsNamespaced(gk) + return namespaced || err != nil +} + +type ResourceKey struct { + Group string + Kind string + Namespace string + Name string +} + +func (k *ResourceKey) String() string { + return fmt.Sprintf("%s/%s/%s/%s", k.Group, k.Kind, k.Namespace, k.Name) +} + +func (k ResourceKey) GroupKind() schema.GroupKind { + return schema.GroupKind{Group: k.Group, Kind: k.Kind} +} + +func NewResourceKey(group string, kind string, namespace string, name string) ResourceKey { + return ResourceKey{Group: group, Kind: kind, Namespace: namespace, Name: name} +} + +func GetResourceKey(obj *unstructured.Unstructured) ResourceKey { + gvk := obj.GroupVersionKind() + return NewResourceKey(gvk.Group, gvk.Kind, obj.GetNamespace(), obj.GetName()) +} + +func GetObjectRef(obj *unstructured.Unstructured) corev1.ObjectReference { + return corev1.ObjectReference{ + UID: obj.GetUID(), + APIVersion: obj.GetAPIVersion(), + Kind: obj.GetKind(), + Name: obj.GetName(), + Namespace: obj.GetNamespace(), + } +} + +// TestConfig tests to make sure the REST config is usable +func TestConfig(config *rest.Config) error { + kubeclientset, err := kubernetes.NewForConfig(config) + if err != nil { + return fmt.Errorf("REST config invalid: %w", err) + } + _, err = kubeclientset.ServerVersion() + if err != nil { + return fmt.Errorf("REST config invalid: %w", err) + } + return nil +} + +// ToUnstructured converts a concrete K8s API type to a un unstructured object +func ToUnstructured(obj any) (*unstructured.Unstructured, error) { + uObj, err := runtime.NewTestUnstructuredConverter(equality.Semantic).ToUnstructured(obj) + if err != nil { + //nolint:wrapcheck // wrap outside this function + return nil, err + } + return &unstructured.Unstructured{Object: uObj}, nil +} + +// MustToUnstructured converts a concrete K8s API type to a un unstructured object and panics if not successful +func MustToUnstructured(obj any) *unstructured.Unstructured { + uObj, err := ToUnstructured(obj) + if err != nil { + panic(err) + } + return uObj +} + +// GetAppInstanceLabel returns the application instance name from labels +func GetAppInstanceLabel(un *unstructured.Unstructured, key string) string { + if labels := un.GetLabels(); labels != nil { + return labels[key] + } + return "" +} + +// UnsetLabel removes our app labels from an unstructured object +func UnsetLabel(target *unstructured.Unstructured, key string) { + if labels := target.GetLabels(); labels != nil { + if _, ok := labels[key]; ok { + delete(labels, key) + if len(labels) == 0 { + unstructured.RemoveNestedField(target.Object, "metadata", "labels") + } else { + target.SetLabels(labels) + } + } + } +} + +func ToGroupVersionResource(groupVersion string, apiResource *metav1.APIResource) schema.GroupVersionResource { + gvk := schema.FromAPIVersionAndKind(groupVersion, apiResource.Kind) + gv := gvk.GroupVersion() + return gv.WithResource(apiResource.Name) +} + +func ToResourceInterface(dynamicIf dynamic.Interface, apiResource *metav1.APIResource, resource schema.GroupVersionResource, namespace string) dynamic.ResourceInterface { + if apiResource.Namespaced { + return dynamicIf.Resource(resource).Namespace(namespace) + } + return dynamicIf.Resource(resource) +} + +func IsCRDGroupVersionKind(gvk schema.GroupVersionKind) bool { + return gvk.Kind == CustomResourceDefinitionKind && gvk.Group == "apiextensions.k8s.io" +} + +func IsCRD(obj *unstructured.Unstructured) bool { + return IsCRDGroupVersionKind(obj.GroupVersionKind()) +} + +// ServerResourceForGroupVersionKind looks up and returns the API resource from +// the server for a given GVK scheme. If verb is set to the non-empty string, +// it will return the API resource which supports the verb. There are some edge +// cases, where the same GVK is represented by more than one API. +// +// See: https://github.com/ksonnet/ksonnet/blob/master/utils/client.go +func ServerResourceForGroupVersionKind(disco discovery.DiscoveryInterface, gvk schema.GroupVersionKind, verb string) (*metav1.APIResource, error) { + // default is to return a not found for the requested resource + retErr := apierrors.NewNotFound(schema.GroupResource{Group: gvk.Group, Resource: gvk.Kind}, "") + resources, err := disco.ServerResourcesForGroupVersion(gvk.GroupVersion().String()) + if err != nil { + return nil, fmt.Errorf("failed to discover server resources for group version %s: %w", gvk.GroupVersion().String(), err) + } + for _, r := range resources.APIResources { + if r.Kind == gvk.Kind { + if isSupportedVerb(&r, verb) { + return &r, nil + } + // We have a match, but the API does not support the action + // that was requested. Memorize this. + retErr = apierrors.NewMethodNotSupported(schema.GroupResource{Group: gvk.Group, Resource: gvk.Kind}, verb) + } + } + return nil, retErr +} + +var ( + kubectlErrOutRegexp = regexp.MustCompile(`^(error: )?(error validating|error when creating|error when creating) "\S+": `) + + // See ApplyOpts::Run() + // cmdutil.AddSourceToErr(fmt.Sprintf("applying patch:\n%s\nto:\n%v\nfor:", patchBytes, info), info.Source, err) + kubectlApplyPatchErrOutRegexp = regexp.MustCompile(`(?s)^error when applying patch:.*\nfor: "\S+": `) + + kubectlErrOutMapRegexp = regexp.MustCompile(`map\[.*\]`) +) + +// cleanKubectlOutput makes the error output of kubectl a little better to read +func cleanKubectlOutput(s string) string { + s = strings.TrimSpace(s) + s = kubectlErrOutRegexp.ReplaceAllString(s, "") + s = kubectlErrOutMapRegexp.ReplaceAllString(s, "") + s = kubectlApplyPatchErrOutRegexp.ReplaceAllString(s, "") + s = strings.ReplaceAll(s, "; if you choose to ignore these errors, turn validation off with --validate=false", "") + return s +} + +// WriteKubeConfig takes a rest.Config and writes it as a kubeconfig at the specified path +func WriteKubeConfig(restConfig *rest.Config, namespace, filename string) error { + kubeConfig := NewKubeConfig(restConfig, namespace) + // nolint:wrapcheck // wrapped error message would be the same as caller's wrapped message + return clientcmd.WriteToFile(*kubeConfig, filename) +} + +// NewKubeConfig converts a clientcmdapi.Config (kubeconfig) from a rest.Config +func NewKubeConfig(restConfig *rest.Config, namespace string) *clientcmdapi.Config { + var proxyUrl string + if restConfig.Proxy != nil { + if u, err := restConfig.Proxy(nil); err == nil { + proxyUrl = u.String() + } + } + return &clientcmdapi.Config{ + CurrentContext: restConfig.Host, + Contexts: map[string]*clientcmdapi.Context{ + restConfig.Host: { + Cluster: restConfig.Host, + AuthInfo: restConfig.Host, + Namespace: namespace, + }, + }, + Clusters: map[string]*clientcmdapi.Cluster{ + restConfig.Host: { + Server: restConfig.Host, + TLSServerName: restConfig.ServerName, + InsecureSkipTLSVerify: restConfig.Insecure, + CertificateAuthority: restConfig.CAFile, + CertificateAuthorityData: restConfig.CAData, + ProxyURL: proxyUrl, + }, + }, + AuthInfos: map[string]*clientcmdapi.AuthInfo{ + restConfig.Host: newAuthInfo(restConfig), + }, + } +} + +// newAuthInfo returns an AuthInfo from a rest config, detecting if the rest.Config is an +// in-cluster config and automatically setting the token path appropriately. +func newAuthInfo(restConfig *rest.Config) *clientcmdapi.AuthInfo { + authInfo := clientcmdapi.AuthInfo{} + haveCredentials := false + if restConfig.CertFile != "" { + authInfo.ClientCertificate = restConfig.CertFile + haveCredentials = true + } + if len(restConfig.CertData) > 0 { + authInfo.ClientCertificateData = restConfig.CertData + haveCredentials = true + } + if restConfig.KeyFile != "" { + authInfo.ClientKey = restConfig.KeyFile + haveCredentials = true + } + if len(restConfig.KeyData) > 0 { + authInfo.ClientKeyData = restConfig.KeyData + haveCredentials = true + } + if restConfig.Username != "" { + authInfo.Username = restConfig.Username + haveCredentials = true + } + if restConfig.Password != "" { + authInfo.Password = restConfig.Password + haveCredentials = true + } + if restConfig.BearerToken != "" { + authInfo.Token = restConfig.BearerToken + haveCredentials = true + } + if restConfig.ExecProvider != nil { + authInfo.Exec = restConfig.ExecProvider + haveCredentials = true + } + if restConfig.ExecProvider == nil && !haveCredentials { + // If no credentials were set (or there was no exec provider), we assume in-cluster config. + // In-cluster configs from the go-client will no longer set bearer tokens, so we set the + // well known token path. See issue #774 + authInfo.TokenFile = "/var/run/secrets/kubernetes.io/serviceaccount/token" + } + return &authInfo +} + +// SplitYAML splits a YAML file into unstructured objects. Returns list of all unstructured objects +// found in the yaml. If an error occurs, returns objects that have been parsed so far too. +func SplitYAML(yamlData []byte) ([]*unstructured.Unstructured, error) { + var objs []*unstructured.Unstructured + ymls, err := SplitYAMLToString(yamlData) + if err != nil { + return nil, err + } + for _, yml := range ymls { + u := &unstructured.Unstructured{} + if err := yaml.Unmarshal([]byte(yml), u); err != nil { + return objs, fmt.Errorf("failed to unmarshal manifest: %w", err) + } + objs = append(objs, u) + } + return objs, nil +} + +// SplitYAMLToString splits a YAML file into strings. Returns list of yamls +// found in the yaml. If an error occurs, returns objects that have been parsed so far too. +func SplitYAMLToString(yamlData []byte) ([]string, error) { + // Similar way to what kubectl does + // https://github.com/kubernetes/cli-runtime/blob/master/pkg/resource/visitor.go#L573-L600 + // Ideally k8s.io/cli-runtime/pkg/resource.Builder should be used instead of this method. + // E.g. Builder does list unpacking and flattening and this code does not. + d := kubeyaml.NewYAMLOrJSONDecoder(bytes.NewReader(yamlData), 4096) + var objs []string + for { + ext := runtime.RawExtension{} + if err := d.Decode(&ext); err != nil { + if errors.Is(err, io.EOF) { + break + } + return objs, fmt.Errorf("failed to unmarshal manifest: %w", err) + } + ext.Raw = bytes.TrimSpace(ext.Raw) + if len(ext.Raw) == 0 || bytes.Equal(ext.Raw, []byte("null")) { + continue + } + objs = append(objs, string(ext.Raw)) + } + return objs, nil +} + +// WatchWithRetry returns channel of watch events or errors of failed to call watch API. +func WatchWithRetry(ctx context.Context, getWatch func() (watch.Interface, error)) chan struct { + *watch.Event + Error error +} { + ch := make(chan struct { + *watch.Event + Error error + }) + execute := func() (bool, error) { + w, err := getWatch() + if err != nil { + return false, err + } + defer w.Stop() + + for { + select { + case event, ok := <-w.ResultChan(): + if ok { + ch <- struct { + *watch.Event + Error error + }{Event: &event, Error: nil} + } else { + return true, nil + } + case <-ctx.Done(): + return false, nil + } + } + } + go func() { + defer close(ch) + for { + retry, err := execute() + if err != nil { + ch <- struct { + *watch.Event + Error error + }{Error: err} + } + if !retry { + return + } + time.Sleep(time.Second) + } + }() + return ch +} + +func GetDeploymentReplicas(u *unstructured.Unstructured) *int64 { + val, found, err := unstructured.NestedInt64(u.Object, "spec", "replicas") + if !found || err != nil { + return nil + } + return &val +} + +func GetResourceImages(u *unstructured.Unstructured) []string { + var containers []any + var found bool + var err error + var images []string + + containerPaths := [][]string{ + // Resources without template, like pods + {"spec", "containers"}, + // Resources with template, like deployments + {"spec", "template", "spec", "containers"}, + // Cronjobs + {"spec", "jobTemplate", "spec", "template", "spec", "containers"}, + } + + for _, path := range containerPaths { + containers, found, err = unstructured.NestedSlice(u.Object, path...) + if found && err == nil { + break + } + } + + if !found || err != nil { + return nil + } + + for _, container := range containers { + containerMap, ok := container.(map[string]any) + if !ok { + continue + } + + image, found, err := unstructured.NestedString(containerMap, "image") + if !found || err != nil { + continue + } + + images = append(images, image) + } + + return images +} + +// RetryUntilSucceed keep retrying given action with specified interval until action succeed or specified context is done. +func RetryUntilSucceed(ctx context.Context, interval time.Duration, desc string, log logr.Logger, action func() error) { + pollErr := wait.PollUntilContextCancel(ctx, interval, true, func(_ context.Context) (bool /*done*/, error) { + log.V(1).Info("Start " + desc) + err := action() + if err == nil { + log.V(1).Info("Completed " + desc) + return true, nil + } + log.V(1).Info(fmt.Sprintf("Failed to %s: %+v, retrying in %v", desc, err, interval)) + return false, nil + }) + if pollErr != nil { + // The only error that can happen here is wait.ErrWaitTimeout if ctx is done. + log.V(1).Info("Stop retrying " + desc) + } +} diff --git a/gitops-engine/pkg/utils/kube/kube_test.go b/gitops-engine/pkg/utils/kube/kube_test.go new file mode 100644 index 0000000000000..e280bd391e604 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/kube_test.go @@ -0,0 +1,397 @@ +package kube + +import ( + "encoding/json" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + extv1beta1 "k8s.io/api/extensions/v1beta1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + fakedisco "k8s.io/client-go/discovery/fake" + "k8s.io/client-go/rest" + testcore "k8s.io/client-go/testing" + clientcmdapi "k8s.io/client-go/tools/clientcmd/api" + "sigs.k8s.io/yaml" +) + +const depWithLabel = ` +apiVersion: extensions/v1beta2 +kind: Deployment +metadata: + name: nginx-deployment + labels: + foo: bar +spec: + template: + metadata: + labels: + app: nginx + spec: + containers: + - image: nginx:1.7.9 + name: nginx + ports: + - containerPort: 80 +` + +var standardVerbs = metav1.Verbs{"create", "delete", "deletecollection", "get", "list", "patch", "update", "watch"} + +func TestUnsetLabels(t *testing.T) { + for _, yamlStr := range [][]byte{[]byte(depWithLabel)} { + var obj unstructured.Unstructured + err := yaml.Unmarshal(yamlStr, &obj) + require.NoError(t, err) + + UnsetLabel(&obj, "foo") + + manifestBytes, err := json.MarshalIndent(obj.Object, "", " ") + require.NoError(t, err) + + var dep extv1beta1.Deployment + err = json.Unmarshal(manifestBytes, &dep) + require.NoError(t, err) + assert.Empty(t, dep.Labels) + } +} + +func TestCleanKubectlOutput(t *testing.T) { + { + s := `error: error validating "STDIN": error validating data: ValidationError(Deployment.spec): missing required field "selector" in io.k8s.api.apps.v1beta2.DeploymentSpec; if you choose to ignore these errors, turn validation off with --validate=false` + assert.Equal(t, `error validating data: ValidationError(Deployment.spec): missing required field "selector" in io.k8s.api.apps.v1beta2.DeploymentSpec`, cleanKubectlOutput(s)) + } + { + s := `error when applying patch: +{"metadata":{"annotations":{"kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"test-immutable-change\"},\"name\":\"my-service\",\"namespace\":\"argocd-e2e--test-immutable-change-ysfud\"},\"spec\":{\"clusterIP\":\"10.96.0.44\",\"ports\":[{\"port\":80,\"protocol\":\"TCP\",\"targetPort\":9376}],\"selector\":{\"app\":\"MyApp\"}}}\n"}},"spec":{"clusterIP":"10.96.0.44"}} +to: +Resource: "/v1, Resource=services", GroupVersionKind: "/v1, Kind=Service" +Name: "my-service", Namespace: "argocd-e2e--test-immutable-change-ysfud" +Object: &{map["apiVersion":"v1" "kind":"Service" "metadata":map["annotations":map["kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"test-immutable-change\"},\"name\":\"my-service\",\"namespace\":\"argocd-e2e--test-immutable-change-ysfud\"},\"spec\":{\"clusterIP\":\"10.96.0.43\",\"ports\":[{\"port\":80,\"protocol\":\"TCP\",\"targetPort\":9376}],\"selector\":{\"app\":\"MyApp\"}}}\n"] "creationTimestamp":"2019-12-11T15:29:56Z" "labels":map["app.kubernetes.io/instance":"test-immutable-change"] "name":"my-service" "namespace":"argocd-e2e--test-immutable-change-ysfud" "resourceVersion":"157426" "selfLink":"/api/v1/namespaces/argocd-e2e--test-immutable-change-ysfud/services/my-service" "uid":"339cf96f-47eb-4759-ac95-30a169dce004"] "spec":map["clusterIP":"10.96.0.43" "ports":[map["port":'P' "protocol":"TCP" "targetPort":'\u24a0']] "selector":map["app":"MyApp"] "sessionAffinity":"None" "type":"ClusterIP"] "status":map["loadBalancer":map[]]]} +for: "/var/folders/_m/991sn1ds7g39lnbhp6wvqp9d_j5476/T/224503547": Service "my-service" is invalid: spec.clusterIP: Invalid value: "10.96.0.44": field is immutable` + assert.Equal(t, `Service "my-service" is invalid: spec.clusterIP: Invalid value: "10.96.0.44": field is immutable`, cleanKubectlOutput(s)) + } + { + s := `error when patching "/var/folders/mj/c96jcs7j2cq7xcjfhqjq3m2w0000gn/T/745145319": "" is invalid: patch: Invalid value: "map[data:map[email:aaaaa password: username:] metadata:map[annotations:map[kubectl.kubernetes.io/last-applied-configuration:{\"apiVersion\":\"v1\",\"data\":{\"email\":\"aaaaa\"},\"kind\":\"Secret\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"test\"},\"name\":\"my-secret\",\"namespace\":\"default\"},\"stringData\":{\"id\":1,\"password\":0,\"username\":\"username\"},\"type\":\"Opaque\"}\n]] stringData:map[id:1 password:0 username:username]]": error decoding from json: illegal base64 data at input byte 4` + assert.Equal(t, `error when patching "/var/folders/mj/c96jcs7j2cq7xcjfhqjq3m2w0000gn/T/745145319": "" is invalid: patch: Invalid value: "": error decoding from json: illegal base64 data at input byte 4`, cleanKubectlOutput(s)) + } + { + s := `error when patching "/var/folders/mj/c96jcs7j2cq7xcjfhqjq3m2w0000gn/T/2250018703": "" is invalid: patch: Invalid value: "map[data: metadata:map[annotations:map[kubectl.kubernetes.io/last-applied-configuration:{\"apiVersion\":\"v1\",\"kind\":\"Secret\",\"metadata\":{\"annotations\":{},\"labels\":{\"app.kubernetes.io/instance\":\"test\"},\"name\":\"my-secret\",\"namespace\":\"default\"},\"stringData\":{\"id\":1,\"password\":0,\"username\":\"username\"},\"type\":\"Opaque\"}\n]]]": cannot convert int64 to string` + assert.Equal(t, `error when patching "/var/folders/mj/c96jcs7j2cq7xcjfhqjq3m2w0000gn/T/2250018703": "" is invalid: patch: Invalid value: "": cannot convert int64 to string`, cleanKubectlOutput(s)) + } + { + s := `Secret in version "v1" cannot be handled as a Secret: json: cannot unmarshal bool into Go struct field Secret.data of type []uint8` + assert.Equal(t, `Secret in version "v1" cannot be handled as a Secret: json: cannot unmarshal bool into Go struct field Secret.data of type []uint8`, cleanKubectlOutput(s)) + } +} + +func TestInClusterKubeConfig(t *testing.T) { + restConfig := &rest.Config{} + kubeConfig := NewKubeConfig(restConfig, "") + assert.NotEmpty(t, kubeConfig.AuthInfos[kubeConfig.CurrentContext].TokenFile) + + restConfig = &rest.Config{ + Password: "foo", + } + kubeConfig = NewKubeConfig(restConfig, "") + assert.Empty(t, kubeConfig.AuthInfos[kubeConfig.CurrentContext].TokenFile) + + restConfig = &rest.Config{ + ExecProvider: &clientcmdapi.ExecConfig{ + APIVersion: "client.authentication.k8s.io/v1alpha1", + Command: "aws", + }, + } + kubeConfig = NewKubeConfig(restConfig, "") + assert.Empty(t, kubeConfig.AuthInfos[kubeConfig.CurrentContext].TokenFile) +} + +func TestNewKubeConfig_TLSServerName(t *testing.T) { + const ( + host = "something.test" + tlsServerName = "something.else.test" + ) + + restConfig := &rest.Config{ + Host: host, + } + kubeConfig := NewKubeConfig(restConfig, "") + assert.Empty(t, kubeConfig.Clusters[host].TLSServerName) + + restConfig = &rest.Config{ + Host: host, + TLSClientConfig: rest.TLSClientConfig{ + ServerName: tlsServerName, + }, + } + kubeConfig = NewKubeConfig(restConfig, "") + assert.Equal(t, tlsServerName, kubeConfig.Clusters[host].TLSServerName) +} + +func TestGetDeploymentReplicas(t *testing.T) { + manifest := []byte(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: nginx-deployment +spec: + replicas: 2 + selector: + matchLabels: + app: nginx + template: + metadata: + labels: + app: nginx + spec: + containers: + - name: nginx + image: nginx:1.7.9 + ports: + - containerPort: 80 +`) + deployment := unstructured.Unstructured{} + err := yaml.Unmarshal(manifest, &deployment) + require.NoError(t, err) + assert.Equal(t, int64(2), *GetDeploymentReplicas(&deployment)) +} + +func TestGetNilDeploymentReplicas(t *testing.T) { + manifest := []byte(` +apiVersion: v1 +kind: Pod +metadata: + name: my-pod +spec: + containers: + - image: nginx:1.7.9 + name: nginx + resources: + requests: + cpu: 0.2 +`) + noDeployment := unstructured.Unstructured{} + err := yaml.Unmarshal(manifest, &noDeployment) + require.NoError(t, err) + assert.Nil(t, GetDeploymentReplicas(&noDeployment)) +} + +func TestGetResourceImages(t *testing.T) { + testCases := []struct { + manifest []byte + expected []string + description string + }{ + { + manifest: []byte(` +apiVersion: extensions/v1beta2 +kind: Deployment +metadata: + name: nginx-deployment + labels: + foo: bar +spec: + template: + metadata: + labels: + app: nginx + spec: + containers: + - name: nginx + image: nginx:1.7.9 + ports: + - containerPort: 80 + - name: agent + image: agent:1.0.0`), + expected: []string{"nginx:1.7.9", "agent:1.0.0"}, + description: "deployment with two containers", + }, + { + manifest: []byte(` +apiVersion: v1 +kind: Pod +metadata: + name: example-pod + labels: + app: my-app +spec: + containers: + - name: nginx-container + image: nginx:1.21 + ports: + - containerPort: 80 + - name: sidecar-container + image: busybox:1.35 + command: ["sh", "-c", "echo Hello from the sidecar; sleep 3600"] +`), + expected: []string{"nginx:1.21", "busybox:1.35"}, + description: "pod with containers", + }, + { + manifest: []byte(` +apiVersion: batch/v1 +kind: CronJob +metadata: + name: hello +spec: + schedule: "* * * * *" + jobTemplate: + spec: + template: + spec: + containers: + - name: hello + image: busybox:1.28 +`), + expected: []string{"busybox:1.28"}, + description: "cronjob with containers", + }, + { + manifest: []byte(` +apiVersion: v1 +kind: ConfigMap +metadata: + name: example-config + namespace: default + labels: + app: my-app +data: + app.properties: | + key1=value1 + key2=value2 + key3=value3 + log.level: debug +`), + expected: nil, + description: "configmap without containers", + }, + { + manifest: []byte(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: deployment-no-containers + labels: + foo: bar +spec: + replicas: 1 + selector: + matchLabels: + app: agent + template: + metadata: + labels: + app: agent + spec: + volumes: + - name: config-volume + configMap: + name: config +`), + expected: nil, + description: "deployment without containers", + }, + { + manifest: []byte(` +apiVersion: apps/v1 +kind: Deployment +metadata: + name: deployment-without-image +spec: + template: + metadata: + labels: + app: nginx + spec: + containers: + - name: text-service + command: ["echo", "hello"] +`), + expected: nil, + description: "deployment with container without image", + }, + { + manifest: []byte(` +apiVersion: v1 +kind: Pod +metadata: + name: example-pod + labels: + app: my-app +spec: + containers: + - name: no-image-container + command: ["echo", "hello"] +`), + expected: nil, + description: "pod with container without image", + }, + } + + for _, tc := range testCases { + t.Run(tc.description, func(t *testing.T) { + resource := unstructured.Unstructured{} + err := yaml.Unmarshal(tc.manifest, &resource) + require.NoError(t, err) + images := GetResourceImages(&resource) + require.Equal(t, tc.expected, images) + }) + } +} + +func TestSplitYAML_SingleObject(t *testing.T) { + objs, err := SplitYAML([]byte(depWithLabel)) + require.NoError(t, err) + assert.Len(t, objs, 1) +} + +func TestSplitYAML_MultipleObjects(t *testing.T) { + objs, err := SplitYAML([]byte(depWithLabel + "\n---\n" + depWithLabel)) + require.NoError(t, err) + assert.Len(t, objs, 2) +} + +func TestSplitYAML_TrailingNewLines(t *testing.T) { + objs, err := SplitYAML([]byte("\n\n\n---" + depWithLabel)) + require.NoError(t, err) + assert.Len(t, objs, 1) +} + +func TestServerResourceGroupForGroupVersionKind(t *testing.T) { + fakeDisco := &fakedisco.FakeDiscovery{Fake: &testcore.Fake{}} + fakeDisco.Resources = append(make([]*metav1.APIResourceList, 0), + &metav1.APIResourceList{ + GroupVersion: "test.argoproj.io/v1alpha1", + APIResources: []metav1.APIResource{ + {Kind: "TestAllVerbs", Group: "test.argoproj.io", Version: "v1alpha1", Namespaced: true, Verbs: standardVerbs}, + {Kind: "TestSomeVerbs", Group: "test.argoproj.io", Version: "v1alpha1", Namespaced: true, Verbs: []string{"get", "list"}}, + }, + }) + + t.Run("Successfully resolve for all verbs", func(t *testing.T) { + for _, v := range standardVerbs { + _, err := ServerResourceForGroupVersionKind(fakeDisco, schema.FromAPIVersionAndKind("test.argoproj.io/v1alpha1", "TestAllVerbs"), v) + assert.NoError(t, err, "Could not resolve verb %s", v) + } + }) + t.Run("Successfully resolve for some verbs", func(t *testing.T) { + for _, v := range []string{"get", "list"} { + _, err := ServerResourceForGroupVersionKind(fakeDisco, schema.FromAPIVersionAndKind("test.argoproj.io/v1alpha1", "TestSomeVerbs"), v) + assert.NoError(t, err, "Could not resolve verb %s", v) + } + }) + t.Run("Verb not supported", func(t *testing.T) { + for _, v := range []string{"patch"} { + _, err := ServerResourceForGroupVersionKind(fakeDisco, schema.FromAPIVersionAndKind("test.argoproj.io/v1alpha1", "TestSomeVerbs"), v) + assert.Equal(t, err, apierrors.NewMethodNotSupported(schema.GroupResource{Group: "test.argoproj.io", Resource: "TestSomeVerbs"}, v)) + } + }) + t.Run("Resource not found", func(t *testing.T) { + for _, v := range standardVerbs { + _, err := ServerResourceForGroupVersionKind(fakeDisco, schema.FromAPIVersionAndKind("test.argoproj.io/v1alpha1", "TestNonExisting"), v) + assert.Equal(t, err, apierrors.NewNotFound(schema.GroupResource{Group: "test.argoproj.io", Resource: "TestNonExisting"}, "")) + } + }) +} diff --git a/gitops-engine/pkg/utils/kube/kubetest/mock.go b/gitops-engine/pkg/utils/kube/kubetest/mock.go new file mode 100644 index 0000000000000..2faa669bf5843 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/kubetest/mock.go @@ -0,0 +1,102 @@ +package kubetest + +import ( + "context" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/managedfields" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" + "k8s.io/kubectl/pkg/util/openapi" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +type KubectlOutput struct { + Output string + Err error +} + +type MockKubectlCmd struct { + APIResources []kube.APIResourceInfo + Commands map[string]KubectlOutput + Events chan watch.Event + Version string + DynamicClient dynamic.Interface + + convertToVersionFunc *func(obj *unstructured.Unstructured, group, version string) (*unstructured.Unstructured, error) + getResourceFunc *func(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error) +} + +// WithConvertToVersionFunc overrides the default ConvertToVersion behavior. +func (k *MockKubectlCmd) WithConvertToVersionFunc(convertToVersionFunc func(*unstructured.Unstructured, string, string) (*unstructured.Unstructured, error)) *MockKubectlCmd { + k.convertToVersionFunc = &convertToVersionFunc + return k +} + +// WithGetResourceFunc overrides the default ConvertToVersion behavior. +func (k *MockKubectlCmd) WithGetResourceFunc(getResourcefunc func(context.Context, *rest.Config, schema.GroupVersionKind, string, string) (*unstructured.Unstructured, error)) *MockKubectlCmd { + k.getResourceFunc = &getResourcefunc + return k +} + +func (k *MockKubectlCmd) NewDynamicClient(_ *rest.Config) (dynamic.Interface, error) { + return k.DynamicClient, nil +} + +func (k *MockKubectlCmd) GetAPIResources(_ *rest.Config, _ bool, _ kube.ResourceFilter) ([]kube.APIResourceInfo, error) { + return k.APIResources, nil +} + +func (k *MockKubectlCmd) GetResource(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error) { + if k.getResourceFunc != nil { + return (*k.getResourceFunc)(ctx, config, gvk, name, namespace) + } + + return nil, nil +} + +func (k *MockKubectlCmd) PatchResource(_ context.Context, _ *rest.Config, _ schema.GroupVersionKind, _ string, _ string, _ types.PatchType, _ []byte, _ ...string) (*unstructured.Unstructured, error) { + return nil, nil +} + +func (k *MockKubectlCmd) DeleteResource(_ context.Context, _ *rest.Config, _ schema.GroupVersionKind, name string, _ string, _ metav1.DeleteOptions) error { + command, ok := k.Commands[name] + if !ok { + return nil + } + return command.Err +} + +func (k *MockKubectlCmd) CreateResource(_ context.Context, _ *rest.Config, _ schema.GroupVersionKind, _ string, _ string, _ *unstructured.Unstructured, _ metav1.CreateOptions, _ ...string) (*unstructured.Unstructured, error) { + return nil, nil +} + +// ConvertToVersion converts an unstructured object into the specified group/version +func (k *MockKubectlCmd) ConvertToVersion(obj *unstructured.Unstructured, group, version string) (*unstructured.Unstructured, error) { + if k.convertToVersionFunc != nil { + return (*k.convertToVersionFunc)(obj, group, version) + } + + return obj, nil +} + +func (k *MockKubectlCmd) GetServerVersion(_ *rest.Config) (string, error) { + return k.Version, nil +} + +func (k *MockKubectlCmd) LoadOpenAPISchema(_ *rest.Config) (openapi.Resources, *managedfields.GvkParser, error) { + return nil, nil, nil +} + +func (k *MockKubectlCmd) SetOnKubectlRun(_ kube.OnKubectlRunFunc) { +} + +func (k *MockKubectlCmd) ManageResources(_ *rest.Config, _ openapi.Resources) (kube.ResourceOperations, func(), error) { + return &MockResourceOps{}, func() { + }, nil +} diff --git a/gitops-engine/pkg/utils/kube/kubetest/mock_resource_operations.go b/gitops-engine/pkg/utils/kube/kubetest/mock_resource_operations.go new file mode 100644 index 0000000000000..8f42428218517 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/kubetest/mock_resource_operations.go @@ -0,0 +1,158 @@ +package kubetest + +import ( + "context" + "sync" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" + cmdutil "k8s.io/kubectl/pkg/cmd/util" + + "github.com/argoproj/gitops-engine/pkg/utils/kube" +) + +type MockResourceOps struct { + Commands map[string]KubectlOutput + Events chan watch.Event + DynamicClient dynamic.Interface + + lastCommandPerResource map[kube.ResourceKey]string + lastValidate bool + serverSideApply bool + serverSideApplyManager string + lastForce bool + + recordLock sync.RWMutex + + getResourceFunc *func(ctx context.Context, config *rest.Config, gvk schema.GroupVersionKind, name string, namespace string) (*unstructured.Unstructured, error) +} + +// WithGetResourceFunc overrides the default ConvertToVersion behavior. +func (r *MockResourceOps) WithGetResourceFunc(getResourcefunc func(context.Context, *rest.Config, schema.GroupVersionKind, string, string) (*unstructured.Unstructured, error)) *MockResourceOps { + r.getResourceFunc = &getResourcefunc + return r +} + +func (r *MockResourceOps) SetLastValidate(validate bool) { + r.recordLock.Lock() + r.lastValidate = validate + r.recordLock.Unlock() +} + +func (r *MockResourceOps) GetLastValidate() bool { + r.recordLock.RLock() + validate := r.lastValidate + r.recordLock.RUnlock() + return validate +} + +func (r *MockResourceOps) SetLastServerSideApply(serverSideApply bool) { + r.recordLock.Lock() + r.serverSideApply = serverSideApply + r.recordLock.Unlock() +} + +func (r *MockResourceOps) GetLastServerSideApplyManager() string { + r.recordLock.Lock() + manager := r.serverSideApplyManager + r.recordLock.Unlock() + return manager +} + +func (r *MockResourceOps) GetLastServerSideApply() bool { + r.recordLock.RLock() + serverSideApply := r.serverSideApply + r.recordLock.RUnlock() + return serverSideApply +} + +func (r *MockResourceOps) SetLastServerSideApplyManager(manager string) { + r.recordLock.Lock() + r.serverSideApplyManager = manager + r.recordLock.Unlock() +} + +func (r *MockResourceOps) SetLastForce(force bool) { + r.recordLock.Lock() + r.lastForce = force + r.recordLock.Unlock() +} + +func (r *MockResourceOps) GetLastForce() bool { + r.recordLock.RLock() + force := r.lastForce + r.recordLock.RUnlock() + return force +} + +func (r *MockResourceOps) SetLastResourceCommand(key kube.ResourceKey, cmd string) { + r.recordLock.Lock() + if r.lastCommandPerResource == nil { + r.lastCommandPerResource = map[kube.ResourceKey]string{} + } + r.lastCommandPerResource[key] = cmd + r.recordLock.Unlock() +} + +func (r *MockResourceOps) GetLastResourceCommand(key kube.ResourceKey) string { + r.recordLock.Lock() + defer r.recordLock.Unlock() + if r.lastCommandPerResource == nil { + return "" + } + return r.lastCommandPerResource[key] +} + +func (r *MockResourceOps) ApplyResource(_ context.Context, obj *unstructured.Unstructured, _ cmdutil.DryRunStrategy, force, validate, serverSideApply bool, manager string) (string, error) { + r.SetLastValidate(validate) + r.SetLastServerSideApply(serverSideApply) + r.SetLastServerSideApplyManager(manager) + r.SetLastForce(force) + r.SetLastResourceCommand(kube.GetResourceKey(obj), "apply") + command, ok := r.Commands[obj.GetName()] + if !ok { + return "", nil + } + + return command.Output, command.Err +} + +func (r *MockResourceOps) ReplaceResource(_ context.Context, obj *unstructured.Unstructured, _ cmdutil.DryRunStrategy, force bool) (string, error) { + r.SetLastForce(force) + command, ok := r.Commands[obj.GetName()] + r.SetLastResourceCommand(kube.GetResourceKey(obj), "replace") + if !ok { + return "", nil + } + + return command.Output, command.Err +} + +func (r *MockResourceOps) UpdateResource(_ context.Context, obj *unstructured.Unstructured, _ cmdutil.DryRunStrategy) (*unstructured.Unstructured, error) { + r.SetLastResourceCommand(kube.GetResourceKey(obj), "update") + command, ok := r.Commands[obj.GetName()] + if !ok { + return obj, nil + } + return obj, command.Err +} + +func (r *MockResourceOps) CreateResource(_ context.Context, obj *unstructured.Unstructured, _ cmdutil.DryRunStrategy, _ bool) (string, error) { + r.SetLastResourceCommand(kube.GetResourceKey(obj), "create") + command, ok := r.Commands[obj.GetName()] + if !ok { + return "", nil + } + return command.Output, command.Err +} + +/*func (r *MockResourceOps) ConvertToVersion(obj *unstructured.Unstructured, group, version string) (*unstructured.Unstructured, error) { + if r.convertToVersionFunc != nil { + return (*r.convertToVersionFunc)(obj, group, version) + } + + return obj, nil +}*/ diff --git a/gitops-engine/pkg/utils/kube/resource_filter.go b/gitops-engine/pkg/utils/kube/resource_filter.go new file mode 100644 index 0000000000000..2a33731788186 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/resource_filter.go @@ -0,0 +1,5 @@ +package kube + +type ResourceFilter interface { + IsExcludedResource(group, kind, cluster string) bool +} diff --git a/gitops-engine/pkg/utils/kube/resource_ops.go b/gitops-engine/pkg/utils/kube/resource_ops.go new file mode 100644 index 0000000000000..f08a14141d66e --- /dev/null +++ b/gitops-engine/pkg/utils/kube/resource_ops.go @@ -0,0 +1,649 @@ +package kube + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "os" + "strings" + + "github.com/go-logr/logr" + "github.com/spf13/cobra" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/cli-runtime/pkg/genericclioptions" + "k8s.io/cli-runtime/pkg/printers" + "k8s.io/cli-runtime/pkg/resource" + "k8s.io/client-go/discovery" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + "k8s.io/kubectl/pkg/cmd/apply" + "k8s.io/kubectl/pkg/cmd/auth" + "k8s.io/kubectl/pkg/cmd/create" + "k8s.io/kubectl/pkg/cmd/delete" + "k8s.io/kubectl/pkg/cmd/replace" + cmdutil "k8s.io/kubectl/pkg/cmd/util" + "k8s.io/kubectl/pkg/scheme" + "k8s.io/kubectl/pkg/util/openapi" + + "github.com/argoproj/gitops-engine/pkg/diff" + "github.com/argoproj/gitops-engine/pkg/utils/io" + "github.com/argoproj/gitops-engine/pkg/utils/tracing" +) + +// ResourceOperations provides methods to manage k8s resources +type ResourceOperations interface { + ApplyResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force, validate, serverSideApply bool, manager string) (string, error) + ReplaceResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force bool) (string, error) + CreateResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, validate bool) (string, error) + UpdateResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy) (*unstructured.Unstructured, error) +} + +// This is a generic implementation for doing most kubectl operations. Implements the ResourceOperations interface. +type kubectlResourceOperations struct { + config *rest.Config + log logr.Logger + tracer tracing.Tracer + onKubectlRun OnKubectlRunFunc + fact cmdutil.Factory + openAPISchema openapi.Resources +} + +// This is an implementation specific for doing server-side diff dry runs. Implements the KubeApplier interface. +type kubectlServerSideDiffDryRunApplier struct { + config *rest.Config + log logr.Logger + tracer tracing.Tracer + onKubectlRun OnKubectlRunFunc + fact cmdutil.Factory + openAPISchema openapi.Resources +} + +type commandExecutor func(ioStreams genericclioptions.IOStreams, fileName string) error + +func maybeLogManifest(manifestBytes []byte, log logr.Logger) error { + // log manifest + if log.V(1).Enabled() { + var obj unstructured.Unstructured + err := json.Unmarshal(manifestBytes, &obj) + if err != nil { + return fmt.Errorf("failed to unmarshal object: %w", err) + } + redacted, _, err := diff.HideSecretData(&obj, nil, nil) + if err != nil { + return fmt.Errorf("failed to hide secret data: %w", err) + } + redactedBytes, err := json.Marshal(redacted) + if err != nil { + return fmt.Errorf("failed to marshal redacted object: %w", err) + } + log.V(1).Info(string(redactedBytes)) + } + return nil +} + +func createManifestFile(obj *unstructured.Unstructured, log logr.Logger) (*os.File, error) { + manifestBytes, err := json.Marshal(obj) + if err != nil { + return nil, fmt.Errorf("failed to marshal object: %w", err) + } + manifestFile, err := os.CreateTemp(io.TempDir, "") + if err != nil { + return nil, fmt.Errorf("failed to generate temp file for manifest: %w", err) + } + if _, err = manifestFile.Write(manifestBytes); err != nil { + return nil, fmt.Errorf("failed to write manifest: %w", err) + } + if err = manifestFile.Close(); err != nil { + return nil, fmt.Errorf("failed to close manifest: %w", err) + } + + err = maybeLogManifest(manifestBytes, log) + if err != nil { + return nil, err + } + return manifestFile, nil +} + +func (k *kubectlResourceOperations) runResourceCommand(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, executor commandExecutor) (string, error) { + manifestFile, err := createManifestFile(obj, k.log) + if err != nil { + return "", err + } + defer io.DeleteFile(manifestFile.Name()) + + var out []string + // rbac resouces are first applied with auth reconcile kubectl feature. + if obj.GetAPIVersion() == "rbac.authorization.k8s.io/v1" { + outReconcile, err := k.rbacReconcile(ctx, obj, manifestFile.Name(), dryRunStrategy) + if err != nil { + return "", fmt.Errorf("error running rbacReconcile: %w", err) + } + out = append(out, outReconcile) + // We still want to fallthrough and run `kubectl apply` in order set the + // last-applied-configuration annotation in the object. + } + + // Run kubectl apply + ioStreams := genericclioptions.IOStreams{ + In: &bytes.Buffer{}, + Out: &bytes.Buffer{}, + ErrOut: &bytes.Buffer{}, + } + err = executor(ioStreams, manifestFile.Name()) + if err != nil { + return "", errors.New(cleanKubectlOutput(err.Error())) + } + if buf := strings.TrimSpace(ioStreams.Out.(*bytes.Buffer).String()); len(buf) > 0 { + out = append(out, buf) + } + if buf := strings.TrimSpace(ioStreams.ErrOut.(*bytes.Buffer).String()); len(buf) > 0 { + out = append(out, buf) + } + return strings.Join(out, ". "), nil +} + +func (k *kubectlServerSideDiffDryRunApplier) runResourceCommand(obj *unstructured.Unstructured, executor commandExecutor) (string, error) { + manifestFile, err := createManifestFile(obj, k.log) + if err != nil { + return "", err + } + defer io.DeleteFile(manifestFile.Name()) + + stdoutBuf := &bytes.Buffer{} + stderrBuf := &bytes.Buffer{} + + // Run kubectl apply + ioStreams := genericclioptions.IOStreams{ + In: &bytes.Buffer{}, + Out: stdoutBuf, + ErrOut: stderrBuf, + } + err = executor(ioStreams, manifestFile.Name()) + if err != nil { + return "", errors.New(cleanKubectlOutput(err.Error())) + } + stdout := stdoutBuf.String() + stderr := stderrBuf.String() + + if stderr != "" && stdout == "" { + err := fmt.Errorf("server-side dry run apply had non-empty stderr: %s", stderr) + k.log.Error(err, "server-side diff") + return "", err + } + if stderr != "" { + k.log.Info("Warning: Server-side dry run apply had non-empty stderr: %s", stderr) + } + return stdout, nil +} + +// rbacReconcile will perform reconciliation for RBAC resources. It will run +// the following command: +// +// kubectl auth reconcile +// +// This is preferred over `kubectl apply`, which cannot tolerate changes in +// roleRef, which is an immutable field. +// See: https://github.com/kubernetes/kubernetes/issues/66353 +// `auth reconcile` will delete and recreate the resource if necessary +func (k *kubectlResourceOperations) rbacReconcile(ctx context.Context, obj *unstructured.Unstructured, fileName string, dryRunStrategy cmdutil.DryRunStrategy) (string, error) { + cleanup, err := processKubectlRun(k.onKubectlRun, "auth") + if err != nil { + return "", fmt.Errorf("error processing kubectl run auth: %w", err) + } + defer cleanup() + outReconcile, err := k.authReconcile(ctx, obj, fileName, dryRunStrategy) + if err != nil { + return "", fmt.Errorf("error running kubectl auth reconcile: %w", err) + } + return outReconcile, nil +} + +func kubeCmdFactory(kubeconfig, ns string, config *rest.Config) cmdutil.Factory { + kubeConfigFlags := genericclioptions.NewConfigFlags(true) + if ns != "" { + kubeConfigFlags.Namespace = &ns + } + kubeConfigFlags.KubeConfig = &kubeconfig + kubeConfigFlags.WithDiscoveryBurst(config.Burst) + kubeConfigFlags.WithDiscoveryQPS(config.QPS) + kubeConfigFlags.Impersonate = &config.Impersonate.UserName + kubeConfigFlags.ImpersonateUID = &config.Impersonate.UID + kubeConfigFlags.ImpersonateGroup = &config.Impersonate.Groups + matchVersionKubeConfigFlags := cmdutil.NewMatchVersionFlags(kubeConfigFlags) + return cmdutil.NewFactory(matchVersionKubeConfigFlags) +} + +func (k *kubectlResourceOperations) ReplaceResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force bool) (string, error) { + span := k.tracer.StartSpan("ReplaceResource") + span.SetBaggageItem("kind", obj.GetKind()) + span.SetBaggageItem("name", obj.GetName()) + defer span.Finish() + k.log.Info(fmt.Sprintf("Replacing resource %s/%s in cluster: %s, namespace: %s", obj.GetKind(), obj.GetName(), k.config.Host, obj.GetNamespace())) + return k.runResourceCommand(ctx, obj, dryRunStrategy, func(ioStreams genericclioptions.IOStreams, fileName string) error { + cleanup, err := processKubectlRun(k.onKubectlRun, "replace") + if err != nil { + return err + } + defer cleanup() + + replaceOptions, err := k.newReplaceOptions(k.config, k.fact, ioStreams, fileName, obj.GetNamespace(), force, dryRunStrategy) + if err != nil { + return err + } + + return replaceOptions.Run(k.fact) + }) +} + +func (k *kubectlResourceOperations) CreateResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, validate bool) (string, error) { + gvk := obj.GroupVersionKind() + span := k.tracer.StartSpan("CreateResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", obj.GetName()) + defer span.Finish() + return k.runResourceCommand(ctx, obj, dryRunStrategy, func(ioStreams genericclioptions.IOStreams, fileName string) error { + cleanup, err := processKubectlRun(k.onKubectlRun, "create") + if err != nil { + return err + } + defer cleanup() + + createOptions, err := k.newCreateOptions(ioStreams, fileName, dryRunStrategy) + if err != nil { + return err + } + command := &cobra.Command{} + saveConfig := false + command.Flags().BoolVar(&saveConfig, "save-config", false, "") + val := false + command.Flags().BoolVar(&val, "validate", false, "") + if validate { + _ = command.Flags().Set("validate", "true") + } + + return createOptions.RunCreate(k.fact, command) + }) +} + +func (k *kubectlResourceOperations) UpdateResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy) (*unstructured.Unstructured, error) { + gvk := obj.GroupVersionKind() + span := k.tracer.StartSpan("UpdateResource") + span.SetBaggageItem("kind", gvk.Kind) + span.SetBaggageItem("name", obj.GetName()) + defer span.Finish() + dynamicIf, err := dynamic.NewForConfig(k.config) + if err != nil { + return nil, fmt.Errorf("error creating dynamic client for config: %w", err) + } + disco, err := discovery.NewDiscoveryClientForConfig(k.config) + if err != nil { + return nil, fmt.Errorf("error creating discovery client for config: %w", err) + } + apiResource, err := ServerResourceForGroupVersionKind(disco, gvk, "update") + if err != nil { + return nil, fmt.Errorf("error creating discovery client for config: %w", err) + } + resource := gvk.GroupVersion().WithResource(apiResource.Name) + resourceIf := ToResourceInterface(dynamicIf, apiResource, resource, obj.GetNamespace()) + + updateOptions := metav1.UpdateOptions{} + switch dryRunStrategy { + case cmdutil.DryRunClient, cmdutil.DryRunServer: + updateOptions.DryRun = []string{metav1.DryRunAll} + } + //nolint:wrapcheck // wrapped error message would be same as caller's wrapped message + return resourceIf.Update(ctx, obj, updateOptions) +} + +// ApplyResource performs an apply of a unstructured resource +func (k *kubectlServerSideDiffDryRunApplier) ApplyResource(_ context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force, validate, serverSideApply bool, manager string) (string, error) { + span := k.tracer.StartSpan("ApplyResource") + span.SetBaggageItem("kind", obj.GetKind()) + span.SetBaggageItem("name", obj.GetName()) + defer span.Finish() + k.log.V(1).WithValues( + "dry-run", [...]string{"none", "client", "server"}[dryRunStrategy], + "manager", manager, + "serverSideApply", serverSideApply).Info(fmt.Sprintf("Running server-side diff. Dry run applying resource %s/%s in cluster: %s, namespace: %s", obj.GetKind(), obj.GetName(), k.config.Host, obj.GetNamespace())) + + return k.runResourceCommand(obj, func(ioStreams genericclioptions.IOStreams, fileName string) error { + cleanup, err := processKubectlRun(k.onKubectlRun, "apply") + if err != nil { + return err + } + defer cleanup() + + applyOpts, err := k.newApplyOptions(ioStreams, obj, fileName, validate, force, serverSideApply, dryRunStrategy, manager) + if err != nil { + return err + } + return applyOpts.Run() + }) +} + +// ApplyResource performs an apply of a unstructured resource +func (k *kubectlResourceOperations) ApplyResource(ctx context.Context, obj *unstructured.Unstructured, dryRunStrategy cmdutil.DryRunStrategy, force, validate, serverSideApply bool, manager string) (string, error) { + span := k.tracer.StartSpan("ApplyResource") + span.SetBaggageItem("kind", obj.GetKind()) + span.SetBaggageItem("name", obj.GetName()) + defer span.Finish() + logWithLevel := k.log + if dryRunStrategy != cmdutil.DryRunNone { + logWithLevel = logWithLevel.V(1) + } + logWithLevel.WithValues( + "dry-run", [...]string{"none", "client", "server"}[dryRunStrategy], + "manager", manager, + "serverSideApply", serverSideApply, + "serverSideDiff", true).Info(fmt.Sprintf("Applying resource %s/%s in cluster: %s, namespace: %s", obj.GetKind(), obj.GetName(), k.config.Host, obj.GetNamespace())) + + return k.runResourceCommand(ctx, obj, dryRunStrategy, func(ioStreams genericclioptions.IOStreams, fileName string) error { + cleanup, err := processKubectlRun(k.onKubectlRun, "apply") + if err != nil { + return err + } + defer cleanup() + + applyOpts, err := k.newApplyOptions(ioStreams, obj, fileName, validate, force, serverSideApply, dryRunStrategy, manager) + if err != nil { + return err + } + return applyOpts.Run() + }) +} + +func newApplyOptionsCommon(config *rest.Config, fact cmdutil.Factory, ioStreams genericclioptions.IOStreams, obj *unstructured.Unstructured, fileName string, validate bool, force, serverSideApply bool, dryRunStrategy cmdutil.DryRunStrategy, manager string) (*apply.ApplyOptions, error) { + flags := apply.NewApplyFlags(ioStreams) + o := &apply.ApplyOptions{ + IOStreams: ioStreams, + VisitedUids: sets.Set[types.UID]{}, + VisitedNamespaces: sets.Set[string]{}, + Recorder: genericclioptions.NoopRecorder{}, + PrintFlags: flags.PrintFlags, + Overwrite: true, + OpenAPIPatch: true, + ServerSideApply: serverSideApply, + } + dynamicClient, err := dynamic.NewForConfig(config) + if err != nil { + return nil, fmt.Errorf("failed to create dynamic client: %w", err) + } + o.DynamicClient = dynamicClient + o.DeleteOptions, err = delete.NewDeleteFlags("").ToOptions(dynamicClient, ioStreams) + if err != nil { + return nil, fmt.Errorf("failed to create delete flags: %w", err) + } + o.OpenAPIGetter = fact + o.DryRunStrategy = dryRunStrategy + o.FieldManager = manager + validateDirective := metav1.FieldValidationIgnore + if validate { + validateDirective = metav1.FieldValidationStrict + } + o.Validator, err = fact.Validator(validateDirective) + if err != nil { + return nil, fmt.Errorf("failed to create validator: %w", err) + } + o.Builder = fact.NewBuilder() + o.Mapper, err = fact.ToRESTMapper() + if err != nil { + return nil, fmt.Errorf("failed to create restmapper: %w", err) + } + + o.DeleteOptions.Filenames = []string{fileName} + o.Namespace = obj.GetNamespace() + o.DeleteOptions.ForceDeletion = force + o.DryRunStrategy = dryRunStrategy + if manager != "" { + o.FieldManager = manager + } + return o, nil +} + +func (k *kubectlServerSideDiffDryRunApplier) newApplyOptions(ioStreams genericclioptions.IOStreams, obj *unstructured.Unstructured, fileName string, validate bool, force, serverSideApply bool, dryRunStrategy cmdutil.DryRunStrategy, manager string) (*apply.ApplyOptions, error) { + o, err := newApplyOptionsCommon(k.config, k.fact, ioStreams, obj, fileName, validate, force, serverSideApply, dryRunStrategy, manager) + if err != nil { + return nil, err + } + + o.ToPrinter = func(operation string) (printers.ResourcePrinter, error) { + o.PrintFlags.NamePrintFlags.Operation = operation + if o.DryRunStrategy != cmdutil.DryRunServer { + return nil, fmt.Errorf("invalid dry run strategy passed to server-side diff dry run applier: %d, expected %d", o.DryRunStrategy, cmdutil.DryRunServer) + } + // managedFields are required by server-side diff to identify + // changes made by mutation webhooks. + o.PrintFlags.JSONYamlPrintFlags.ShowManagedFields = true + p, err := o.PrintFlags.JSONYamlPrintFlags.ToPrinter("json") + if err != nil { + return nil, fmt.Errorf("error configuring server-side diff printer: %w", err) + } + return p, nil + } + + o.ForceConflicts = true + + if err := o.Validate(); err != nil { + return nil, fmt.Errorf("error validating options: %w", err) + } + return o, nil +} + +func (k *kubectlResourceOperations) newApplyOptions(ioStreams genericclioptions.IOStreams, obj *unstructured.Unstructured, fileName string, validate bool, force, serverSideApply bool, dryRunStrategy cmdutil.DryRunStrategy, manager string) (*apply.ApplyOptions, error) { + o, err := newApplyOptionsCommon(k.config, k.fact, ioStreams, obj, fileName, validate, force, serverSideApply, dryRunStrategy, manager) + if err != nil { + return nil, err + } + + o.ToPrinter = func(operation string) (printers.ResourcePrinter, error) { + o.PrintFlags.NamePrintFlags.Operation = operation + switch o.DryRunStrategy { + case cmdutil.DryRunClient: + err = o.PrintFlags.Complete("%s (dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring client dryrun printer: %w", err) + } + case cmdutil.DryRunServer: + err = o.PrintFlags.Complete("%s (server dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring server dryrun printer: %w", err) + } + } + return o.PrintFlags.ToPrinter() + } + + if serverSideApply { + o.ForceConflicts = true + } + + if err := o.Validate(); err != nil { + return nil, fmt.Errorf("error validating options: %w", err) + } + return o, nil +} + +func (k *kubectlResourceOperations) newCreateOptions(ioStreams genericclioptions.IOStreams, fileName string, dryRunStrategy cmdutil.DryRunStrategy) (*create.CreateOptions, error) { + o := create.NewCreateOptions(ioStreams) + + recorder, err := o.RecordFlags.ToRecorder() + if err != nil { + return nil, fmt.Errorf("error configuring recorder: %w", err) + } + o.Recorder = recorder + + switch dryRunStrategy { + case cmdutil.DryRunClient: + err = o.PrintFlags.Complete("%s (dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring client dryrun printer: %w", err) + } + case cmdutil.DryRunServer: + err = o.PrintFlags.Complete("%s (server dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring server dryrun printer: %w", err) + } + } + o.DryRunStrategy = dryRunStrategy + + printer, err := o.PrintFlags.ToPrinter() + if err != nil { + return nil, fmt.Errorf("error configuring printer: %w", err) + } + o.PrintObj = func(obj runtime.Object) error { + return printer.PrintObj(obj, o.Out) + } + o.FilenameOptions.Filenames = []string{fileName} + + if err := o.Validate(); err != nil { + return nil, fmt.Errorf("error validating options: %w", err) + } + return o, nil +} + +func (k *kubectlResourceOperations) newReplaceOptions(config *rest.Config, f cmdutil.Factory, ioStreams genericclioptions.IOStreams, fileName string, namespace string, force bool, dryRunStrategy cmdutil.DryRunStrategy) (*replace.ReplaceOptions, error) { + o := replace.NewReplaceOptions(ioStreams) + + recorder, err := o.RecordFlags.ToRecorder() + if err != nil { + return nil, fmt.Errorf("error configuring recorder: %w", err) + } + o.Recorder = recorder + + dynamicClient, err := dynamic.NewForConfig(config) + if err != nil { + return nil, fmt.Errorf("error configuring dynamic client: %w", err) + } + + o.DeleteOptions, err = o.DeleteFlags.ToOptions(dynamicClient, o.IOStreams) + if err != nil { + return nil, fmt.Errorf("error configuring delete: %w", err) + } + + o.Builder = func() *resource.Builder { + return f.NewBuilder() + } + + switch dryRunStrategy { + case cmdutil.DryRunClient: + err = o.PrintFlags.Complete("%s (dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring client dryrun printer: %w", err) + } + case cmdutil.DryRunServer: + err = o.PrintFlags.Complete("%s (server dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring server dryrun printer: %w", err) + } + } + o.DryRunStrategy = dryRunStrategy + + printer, err := o.PrintFlags.ToPrinter() + if err != nil { + return nil, fmt.Errorf("error configuring printer: %w", err) + } + o.PrintObj = func(obj runtime.Object) error { + return printer.PrintObj(obj, o.Out) + } + + o.DeleteOptions.Filenames = []string{fileName} + o.Namespace = namespace + + if dryRunStrategy == cmdutil.DryRunNone { + o.DeleteOptions.ForceDeletion = force + } + + if err := o.Validate(); err != nil { + return nil, fmt.Errorf("error validating options: %w", err) + } + return o, nil +} + +func newReconcileOptions(f cmdutil.Factory, kubeClient *kubernetes.Clientset, fileName string, ioStreams genericclioptions.IOStreams, namespace string, dryRunStrategy cmdutil.DryRunStrategy) (*auth.ReconcileOptions, error) { + o := auth.NewReconcileOptions(ioStreams) + o.RBACClient = kubeClient.RbacV1() + o.NamespaceClient = kubeClient.CoreV1() + o.FilenameOptions.Filenames = []string{fileName} + o.DryRun = dryRunStrategy != cmdutil.DryRunNone + + r := f.NewBuilder(). + WithScheme(scheme.Scheme, scheme.Scheme.PrioritizedVersionsAllGroups()...). + NamespaceParam(namespace).DefaultNamespace(). + FilenameParam(false, o.FilenameOptions). + Flatten(). + Do() + o.Visitor = r + + if o.DryRun { + err := o.PrintFlags.Complete("%s (dry run)") + if err != nil { + return nil, fmt.Errorf("error configuring client dryrun printer: %w", err) + } + } + printer, err := o.PrintFlags.ToPrinter() + if err != nil { + return nil, fmt.Errorf("error configuring printer: %w", err) + } + o.PrintObject = printer.PrintObj + + if err := o.Validate(); err != nil { + return nil, fmt.Errorf("error validating options: %w", err) + } + return o, nil +} + +func (k *kubectlResourceOperations) authReconcile(ctx context.Context, obj *unstructured.Unstructured, manifestFile string, dryRunStrategy cmdutil.DryRunStrategy) (string, error) { + kubeClient, err := kubernetes.NewForConfig(k.config) + if err != nil { + return "", fmt.Errorf("error creating kube client: %w", err) + } + // `kubectl auth reconcile` has a side effect of auto-creating namespaces if it doesn't exist. + // See: https://github.com/kubernetes/kubernetes/issues/71185. This is behavior which we do + // not want. We need to check if the namespace exists, before know if it is safe to run this + // command. Skip this for dryRuns. + if dryRunStrategy == cmdutil.DryRunNone && obj.GetNamespace() != "" { + _, err = kubeClient.CoreV1().Namespaces().Get(ctx, obj.GetNamespace(), metav1.GetOptions{}) + if err != nil { + return "", fmt.Errorf("error getting namespace %s: %w", obj.GetNamespace(), err) + } + } + ioStreams := genericclioptions.IOStreams{ + In: &bytes.Buffer{}, + Out: &bytes.Buffer{}, + ErrOut: &bytes.Buffer{}, + } + reconcileOpts, err := newReconcileOptions(k.fact, kubeClient, manifestFile, ioStreams, obj.GetNamespace(), dryRunStrategy) + if err != nil { + return "", fmt.Errorf("error calling newReconcileOptions: %w", err) + } + err = reconcileOpts.Validate() + if err != nil { + return "", errors.New(cleanKubectlOutput(err.Error())) + } + err = reconcileOpts.RunReconcile() + if err != nil { + return "", errors.New(cleanKubectlOutput(err.Error())) + } + + var out []string + if buf := strings.TrimSpace(ioStreams.Out.(*bytes.Buffer).String()); len(buf) > 0 { + out = append(out, buf) + } + if buf := strings.TrimSpace(ioStreams.ErrOut.(*bytes.Buffer).String()); len(buf) > 0 { + out = append(out, buf) + } + return strings.Join(out, ". "), nil +} + +func processKubectlRun(onKubectlRun OnKubectlRunFunc, cmd string) (CleanupFunc, error) { + if onKubectlRun != nil { + return onKubectlRun(cmd) + } + return func() {}, nil +} diff --git a/gitops-engine/pkg/utils/kube/scheme/parser.go b/gitops-engine/pkg/utils/kube/scheme/parser.go new file mode 100644 index 0000000000000..b65e5700fa503 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/scheme/parser.go @@ -0,0 +1,15450 @@ +// Code generated by hack/update_static_schema.sh; DO NOT EDIT. +// Everything below is downloaded from applyconfigurations/internal/internal.go in kubernetes/client-go. + +/* +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 applyconfiguration-gen. DO NOT EDIT. + +package scheme + +import ( + fmt "fmt" + sync "sync" + + typed "sigs.k8s.io/structured-merge-diff/v6/typed" +) + +func StaticParser() *typed.Parser { + parserOnce.Do(func() { + var err error + parser, err = typed.NewParser(schemaYAML) + if err != nil { + panic(fmt.Sprintf("Failed to parse schema: %v", err)) + } + }) + return parser +} + +var parserOnce sync.Once +var parser *typed.Parser +var schemaYAML = typed.YAMLObject(`types: +- name: io.k8s.api.admissionregistration.v1.AuditAnnotation + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: valueExpression + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1.ExpressionWarning + map: + fields: + - name: fieldRef + type: + scalar: string + default: "" + - name: warning + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1.MatchCondition + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1.MatchResources + map: + fields: + - name: excludeResourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.NamedRuleWithOperations + elementRelationship: atomic + - name: matchPolicy + type: + scalar: string + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.NamedRuleWithOperations + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.MutatingWebhook + map: + fields: + - name: admissionReviewVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: clientConfig + type: + namedType: io.k8s.api.admissionregistration.v1.WebhookClientConfig + default: {} + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchPolicy + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: reinvocationPolicy + type: + scalar: string + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.RuleWithOperations + elementRelationship: atomic + - name: sideEffects + type: + scalar: string + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1.MutatingWebhookConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: webhooks + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.MutatingWebhook + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1.NamedRuleWithOperations + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: apiVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: operations + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: scope + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.ParamKind + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.ParamRef + map: + fields: + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: parameterNotFoundAction + type: + scalar: string + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.RuleWithOperations + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: apiVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: operations + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: scope + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1.ServiceReference + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" + - name: path + type: + scalar: string + - name: port + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1.TypeChecking + map: + fields: + - name: expressionWarnings + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.ExpressionWarning + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicySpec + default: {} + - name: status + type: + namedType: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicyStatus + default: {} +- name: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicyBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicyBindingSpec + default: {} +- name: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicyBindingSpec + map: + fields: + - name: matchResources + type: + namedType: io.k8s.api.admissionregistration.v1.MatchResources + - name: paramRef + type: + namedType: io.k8s.api.admissionregistration.v1.ParamRef + - name: policyName + type: + scalar: string + - name: validationActions + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicySpec + map: + fields: + - name: auditAnnotations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.AuditAnnotation + elementRelationship: atomic + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchConstraints + type: + namedType: io.k8s.api.admissionregistration.v1.MatchResources + - name: paramKind + type: + namedType: io.k8s.api.admissionregistration.v1.ParamKind + - name: validations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.Validation + elementRelationship: atomic + - name: variables + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.Variable + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1.ValidatingAdmissionPolicyStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: typeChecking + type: + namedType: io.k8s.api.admissionregistration.v1.TypeChecking +- name: io.k8s.api.admissionregistration.v1.ValidatingWebhook + map: + fields: + - name: admissionReviewVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: clientConfig + type: + namedType: io.k8s.api.admissionregistration.v1.WebhookClientConfig + default: {} + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchPolicy + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.RuleWithOperations + elementRelationship: atomic + - name: sideEffects + type: + scalar: string + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1.ValidatingWebhookConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: webhooks + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.ValidatingWebhook + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1.Validation + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: message + type: + scalar: string + - name: messageExpression + type: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1.Variable + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1.WebhookClientConfig + map: + fields: + - name: caBundle + type: + scalar: string + - name: service + type: + namedType: io.k8s.api.admissionregistration.v1.ServiceReference + - name: url + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1alpha1.ApplyConfiguration + map: + fields: + - name: expression + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1alpha1.AuditAnnotation + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: valueExpression + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1alpha1.ExpressionWarning + map: + fields: + - name: fieldRef + type: + scalar: string + default: "" + - name: warning + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1alpha1.JSONPatch + map: + fields: + - name: expression + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1alpha1.MatchCondition + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1alpha1.MatchResources + map: + fields: + - name: excludeResourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.NamedRuleWithOperations + elementRelationship: atomic + - name: matchPolicy + type: + scalar: string + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.NamedRuleWithOperations + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicySpec + default: {} +- name: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicyBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicyBindingSpec + default: {} +- name: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicyBindingSpec + map: + fields: + - name: matchResources + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchResources + - name: paramRef + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ParamRef + - name: policyName + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1alpha1.MutatingAdmissionPolicySpec + map: + fields: + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchConstraints + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchResources + - name: mutations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.Mutation + elementRelationship: atomic + - name: paramKind + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ParamKind + - name: reinvocationPolicy + type: + scalar: string + - name: variables + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.Variable + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.Mutation + map: + fields: + - name: applyConfiguration + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ApplyConfiguration + - name: jsonPatch + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.JSONPatch + - name: patchType + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1alpha1.NamedRuleWithOperations + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: apiVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: operations + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: scope + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.ParamKind + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.ParamRef + map: + fields: + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: parameterNotFoundAction + type: + scalar: string + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.TypeChecking + map: + fields: + - name: expressionWarnings + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.ExpressionWarning + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicySpec + default: {} + - name: status + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicyStatus + default: {} +- name: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicyBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicyBindingSpec + default: {} +- name: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicyBindingSpec + map: + fields: + - name: matchResources + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchResources + - name: paramRef + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ParamRef + - name: policyName + type: + scalar: string + - name: validationActions + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicySpec + map: + fields: + - name: auditAnnotations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.AuditAnnotation + elementRelationship: atomic + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchConstraints + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.MatchResources + - name: paramKind + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.ParamKind + - name: validations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.Validation + elementRelationship: atomic + - name: variables + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1alpha1.Variable + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1alpha1.ValidatingAdmissionPolicyStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: typeChecking + type: + namedType: io.k8s.api.admissionregistration.v1alpha1.TypeChecking +- name: io.k8s.api.admissionregistration.v1alpha1.Validation + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: message + type: + scalar: string + - name: messageExpression + type: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1alpha1.Variable + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1beta1.AuditAnnotation + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: valueExpression + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1beta1.ExpressionWarning + map: + fields: + - name: fieldRef + type: + scalar: string + default: "" + - name: warning + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1beta1.MatchCondition + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.admissionregistration.v1beta1.MatchResources + map: + fields: + - name: excludeResourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.NamedRuleWithOperations + elementRelationship: atomic + - name: matchPolicy + type: + scalar: string + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.NamedRuleWithOperations + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.MutatingWebhook + map: + fields: + - name: admissionReviewVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: clientConfig + type: + namedType: io.k8s.api.admissionregistration.v1beta1.WebhookClientConfig + default: {} + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchPolicy + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: reinvocationPolicy + type: + scalar: string + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.RuleWithOperations + elementRelationship: atomic + - name: sideEffects + type: + scalar: string + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1beta1.MutatingWebhookConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: webhooks + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.MutatingWebhook + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1beta1.NamedRuleWithOperations + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: apiVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: operations + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: scope + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.ParamKind + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.ParamRef + map: + fields: + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: parameterNotFoundAction + type: + scalar: string + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.ServiceReference + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" + - name: path + type: + scalar: string + - name: port + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1beta1.TypeChecking + map: + fields: + - name: expressionWarnings + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.ExpressionWarning + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicySpec + default: {} + - name: status + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicyStatus + default: {} +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicyBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicyBindingSpec + default: {} +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicyBindingSpec + map: + fields: + - name: matchResources + type: + namedType: io.k8s.api.admissionregistration.v1beta1.MatchResources + - name: paramRef + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ParamRef + - name: policyName + type: + scalar: string + - name: validationActions + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicySpec + map: + fields: + - name: auditAnnotations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.AuditAnnotation + elementRelationship: atomic + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchConstraints + type: + namedType: io.k8s.api.admissionregistration.v1beta1.MatchResources + - name: paramKind + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ParamKind + - name: validations + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.Validation + elementRelationship: atomic + - name: variables + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.Variable + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingAdmissionPolicyStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: typeChecking + type: + namedType: io.k8s.api.admissionregistration.v1beta1.TypeChecking +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingWebhook + map: + fields: + - name: admissionReviewVersions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: clientConfig + type: + namedType: io.k8s.api.admissionregistration.v1beta1.WebhookClientConfig + default: {} + - name: failurePolicy + type: + scalar: string + - name: matchConditions + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.MatchCondition + elementRelationship: associative + keys: + - name + - name: matchPolicy + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: objectSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1.RuleWithOperations + elementRelationship: atomic + - name: sideEffects + type: + scalar: string + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: webhooks + type: + list: + elementType: + namedType: io.k8s.api.admissionregistration.v1beta1.ValidatingWebhook + elementRelationship: associative + keys: + - name +- name: io.k8s.api.admissionregistration.v1beta1.Validation + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: message + type: + scalar: string + - name: messageExpression + type: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.admissionregistration.v1beta1.Variable + map: + fields: + - name: expression + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.admissionregistration.v1beta1.WebhookClientConfig + map: + fields: + - name: caBundle + type: + scalar: string + - name: service + type: + namedType: io.k8s.api.admissionregistration.v1beta1.ServiceReference + - name: url + type: + scalar: string +- name: io.k8s.api.apiserverinternal.v1alpha1.ServerStorageVersion + map: + fields: + - name: apiServerID + type: + scalar: string + - name: decodableVersions + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: encodingVersion + type: + scalar: string + - name: servedVersions + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.apiserverinternal.v1alpha1.StorageVersion + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionStatus + default: {} +- name: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: reason + type: + scalar: string + default: "" + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionSpec + map: + elementType: + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_deduced_ + elementRelationship: separable +- name: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionStatus + map: + fields: + - name: commonEncodingVersion + type: + scalar: string + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apiserverinternal.v1alpha1.StorageVersionCondition + elementRelationship: associative + keys: + - type + - name: storageVersions + type: + list: + elementType: + namedType: io.k8s.api.apiserverinternal.v1alpha1.ServerStorageVersion + elementRelationship: associative + keys: + - apiServerID +- name: io.k8s.api.apps.v1.ControllerRevision + map: + fields: + - name: apiVersion + type: + scalar: string + - name: data + type: + namedType: __untyped_atomic_ + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: revision + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1.DaemonSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1.DaemonSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1.DaemonSetStatus + default: {} +- name: io.k8s.api.apps.v1.DaemonSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1.DaemonSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: updateStrategy + type: + namedType: io.k8s.api.apps.v1.DaemonSetUpdateStrategy + default: {} +- name: io.k8s.api.apps.v1.DaemonSetStatus + map: + fields: + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1.DaemonSetCondition + elementRelationship: associative + keys: + - type + - name: currentNumberScheduled + type: + scalar: numeric + default: 0 + - name: desiredNumberScheduled + type: + scalar: numeric + default: 0 + - name: numberAvailable + type: + scalar: numeric + - name: numberMisscheduled + type: + scalar: numeric + default: 0 + - name: numberReady + type: + scalar: numeric + default: 0 + - name: numberUnavailable + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: updatedNumberScheduled + type: + scalar: numeric +- name: io.k8s.api.apps.v1.DaemonSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1.RollingUpdateDaemonSet + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1.Deployment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1.DeploymentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1.DeploymentStatus + default: {} +- name: io.k8s.api.apps.v1.DeploymentCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1.DeploymentSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: paused + type: + scalar: boolean + - name: progressDeadlineSeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: strategy + type: + namedType: io.k8s.api.apps.v1.DeploymentStrategy + default: {} + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.apps.v1.DeploymentStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1.DeploymentCondition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: terminatingReplicas + type: + scalar: numeric + - name: unavailableReplicas + type: + scalar: numeric + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1.DeploymentStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1.RollingUpdateDeployment + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1.ReplicaSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1.ReplicaSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1.ReplicaSetStatus + default: {} +- name: io.k8s.api.apps.v1.ReplicaSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1.ReplicaSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.apps.v1.ReplicaSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1.ReplicaSetCondition + elementRelationship: associative + keys: + - type + - name: fullyLabeledReplicas + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: terminatingReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1.RollingUpdateDaemonSet + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.apps.v1.RollingUpdateDeployment + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy + map: + fields: + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: partition + type: + scalar: numeric +- name: io.k8s.api.apps.v1.StatefulSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1.StatefulSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1.StatefulSetStatus + default: {} +- name: io.k8s.api.apps.v1.StatefulSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1.StatefulSetOrdinals + map: + fields: + - name: start + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string +- name: io.k8s.api.apps.v1.StatefulSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: ordinals + type: + namedType: io.k8s.api.apps.v1.StatefulSetOrdinals + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1.StatefulSetPersistentVolumeClaimRetentionPolicy + - name: podManagementPolicy + type: + scalar: string + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: serviceName + type: + scalar: string + default: "" + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: updateStrategy + type: + namedType: io.k8s.api.apps.v1.StatefulSetUpdateStrategy + default: {} + - name: volumeClaimTemplates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PersistentVolumeClaim + elementRelationship: atomic +- name: io.k8s.api.apps.v1.StatefulSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + default: 0 + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1.StatefulSetCondition + elementRelationship: associative + keys: + - type + - name: currentReplicas + type: + scalar: numeric + - name: currentRevision + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: updateRevision + type: + scalar: string + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1.StatefulSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1.RollingUpdateStatefulSetStrategy + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1beta1.ControllerRevision + map: + fields: + - name: apiVersion + type: + scalar: string + - name: data + type: + namedType: __untyped_atomic_ + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: revision + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1beta1.Deployment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta1.DeploymentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta1.DeploymentStatus + default: {} +- name: io.k8s.api.apps.v1beta1.DeploymentCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta1.DeploymentSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: paused + type: + scalar: boolean + - name: progressDeadlineSeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: rollbackTo + type: + namedType: io.k8s.api.apps.v1beta1.RollbackConfig + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: strategy + type: + namedType: io.k8s.api.apps.v1beta1.DeploymentStrategy + default: {} + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.apps.v1beta1.DeploymentStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta1.DeploymentCondition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: terminatingReplicas + type: + scalar: numeric + - name: unavailableReplicas + type: + scalar: numeric + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta1.DeploymentStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1beta1.RollingUpdateDeployment + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1beta1.RollbackConfig + map: + fields: + - name: revision + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta1.RollingUpdateDeployment + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.apps.v1beta1.RollingUpdateStatefulSetStrategy + map: + fields: + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: partition + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta1.StatefulSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetStatus + default: {} +- name: io.k8s.api.apps.v1beta1.StatefulSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta1.StatefulSetOrdinals + map: + fields: + - name: start + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string +- name: io.k8s.api.apps.v1beta1.StatefulSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: ordinals + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetOrdinals + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy + - name: podManagementPolicy + type: + scalar: string + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: serviceName + type: + scalar: string + default: "" + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: updateStrategy + type: + namedType: io.k8s.api.apps.v1beta1.StatefulSetUpdateStrategy + default: {} + - name: volumeClaimTemplates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PersistentVolumeClaim + elementRelationship: atomic +- name: io.k8s.api.apps.v1beta1.StatefulSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + default: 0 + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta1.StatefulSetCondition + elementRelationship: associative + keys: + - type + - name: currentReplicas + type: + scalar: numeric + - name: currentRevision + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: updateRevision + type: + scalar: string + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta1.StatefulSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1beta1.RollingUpdateStatefulSetStrategy + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1beta2.ControllerRevision + map: + fields: + - name: apiVersion + type: + scalar: string + - name: data + type: + namedType: __untyped_atomic_ + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: revision + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1beta2.DaemonSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta2.DaemonSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta2.DaemonSetStatus + default: {} +- name: io.k8s.api.apps.v1beta2.DaemonSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta2.DaemonSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: updateStrategy + type: + namedType: io.k8s.api.apps.v1beta2.DaemonSetUpdateStrategy + default: {} +- name: io.k8s.api.apps.v1beta2.DaemonSetStatus + map: + fields: + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta2.DaemonSetCondition + elementRelationship: associative + keys: + - type + - name: currentNumberScheduled + type: + scalar: numeric + default: 0 + - name: desiredNumberScheduled + type: + scalar: numeric + default: 0 + - name: numberAvailable + type: + scalar: numeric + - name: numberMisscheduled + type: + scalar: numeric + default: 0 + - name: numberReady + type: + scalar: numeric + default: 0 + - name: numberUnavailable + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: updatedNumberScheduled + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta2.DaemonSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1beta2.RollingUpdateDaemonSet + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1beta2.Deployment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta2.DeploymentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta2.DeploymentStatus + default: {} +- name: io.k8s.api.apps.v1beta2.DeploymentCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta2.DeploymentSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: paused + type: + scalar: boolean + - name: progressDeadlineSeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: strategy + type: + namedType: io.k8s.api.apps.v1beta2.DeploymentStrategy + default: {} + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.apps.v1beta2.DeploymentStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta2.DeploymentCondition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: terminatingReplicas + type: + scalar: numeric + - name: unavailableReplicas + type: + scalar: numeric + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta2.DeploymentStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1beta2.RollingUpdateDeployment + - name: type + type: + scalar: string +- name: io.k8s.api.apps.v1beta2.ReplicaSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta2.ReplicaSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta2.ReplicaSetStatus + default: {} +- name: io.k8s.api.apps.v1beta2.ReplicaSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta2.ReplicaSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.apps.v1beta2.ReplicaSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta2.ReplicaSetCondition + elementRelationship: associative + keys: + - type + - name: fullyLabeledReplicas + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: terminatingReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta2.RollingUpdateDaemonSet + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.apps.v1beta2.RollingUpdateDeployment + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.apps.v1beta2.RollingUpdateStatefulSetStrategy + map: + fields: + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: partition + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta2.StatefulSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetStatus + default: {} +- name: io.k8s.api.apps.v1beta2.StatefulSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.apps.v1beta2.StatefulSetOrdinals + map: + fields: + - name: start + type: + scalar: numeric + default: 0 +- name: io.k8s.api.apps.v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy + map: + fields: + - name: whenDeleted + type: + scalar: string + - name: whenScaled + type: + scalar: string +- name: io.k8s.api.apps.v1beta2.StatefulSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: ordinals + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetOrdinals + - name: persistentVolumeClaimRetentionPolicy + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy + - name: podManagementPolicy + type: + scalar: string + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: serviceName + type: + scalar: string + default: "" + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: updateStrategy + type: + namedType: io.k8s.api.apps.v1beta2.StatefulSetUpdateStrategy + default: {} + - name: volumeClaimTemplates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PersistentVolumeClaim + elementRelationship: atomic +- name: io.k8s.api.apps.v1beta2.StatefulSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + default: 0 + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.apps.v1beta2.StatefulSetCondition + elementRelationship: associative + keys: + - type + - name: currentReplicas + type: + scalar: numeric + - name: currentRevision + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: updateRevision + type: + scalar: string + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.apps.v1beta2.StatefulSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.apps.v1beta2.RollingUpdateStatefulSetStrategy + - name: type + type: + scalar: string +- name: io.k8s.api.autoscaling.v1.CrossVersionObjectReference + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.autoscaling.v1.HorizontalPodAutoscaler + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec + default: {} + - name: status + type: + namedType: io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus + default: {} +- name: io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerSpec + map: + fields: + - name: maxReplicas + type: + scalar: numeric + default: 0 + - name: minReplicas + type: + scalar: numeric + - name: scaleTargetRef + type: + namedType: io.k8s.api.autoscaling.v1.CrossVersionObjectReference + default: {} + - name: targetCPUUtilizationPercentage + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v1.HorizontalPodAutoscalerStatus + map: + fields: + - name: currentCPUUtilizationPercentage + type: + scalar: numeric + - name: currentReplicas + type: + scalar: numeric + default: 0 + - name: desiredReplicas + type: + scalar: numeric + default: 0 + - name: lastScaleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2.ContainerResourceMetricSource + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: target + type: + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: current + type: + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2.ExternalMetricSource + map: + fields: + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ExternalMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2.HPAScalingPolicy + map: + fields: + - name: periodSeconds + type: + scalar: numeric + default: 0 + - name: type + type: + scalar: string + default: "" + - name: value + type: + scalar: numeric + default: 0 +- name: io.k8s.api.autoscaling.v2.HPAScalingRules + map: + fields: + - name: policies + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2.HPAScalingPolicy + elementRelationship: atomic + - name: selectPolicy + type: + scalar: string + - name: stabilizationWindowSeconds + type: + scalar: numeric + - name: tolerance + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscaler + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec + default: {} + - name: status + type: + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus + default: {} +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior + map: + fields: + - name: scaleDown + type: + namedType: io.k8s.api.autoscaling.v2.HPAScalingRules + - name: scaleUp + type: + namedType: io.k8s.api.autoscaling.v2.HPAScalingRules +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerSpec + map: + fields: + - name: behavior + type: + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerBehavior + - name: maxReplicas + type: + scalar: numeric + default: 0 + - name: metrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2.MetricSpec + elementRelationship: atomic + - name: minReplicas + type: + scalar: numeric + - name: scaleTargetRef + type: + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + default: {} +- name: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2.HorizontalPodAutoscalerCondition + elementRelationship: associative + keys: + - type + - name: currentMetrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2.MetricStatus + elementRelationship: atomic + - name: currentReplicas + type: + scalar: numeric + - name: desiredReplicas + type: + scalar: numeric + default: 0 + - name: lastScaleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2.MetricIdentifier + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2.MetricSpec + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2.ContainerResourceMetricSource + - name: external + type: + namedType: io.k8s.api.autoscaling.v2.ExternalMetricSource + - name: object + type: + namedType: io.k8s.api.autoscaling.v2.ObjectMetricSource + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2.PodsMetricSource + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2.ResourceMetricSource + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2.MetricStatus + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2.ContainerResourceMetricStatus + - name: external + type: + namedType: io.k8s.api.autoscaling.v2.ExternalMetricStatus + - name: object + type: + namedType: io.k8s.api.autoscaling.v2.ObjectMetricStatus + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2.PodsMetricStatus + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2.ResourceMetricStatus + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2.MetricTarget + map: + fields: + - name: averageUtilization + type: + scalar: numeric + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: type + type: + scalar: string + default: "" + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2.MetricValueStatus + map: + fields: + - name: averageUtilization + type: + scalar: numeric + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2.ObjectMetricSource + map: + fields: + - name: describedObject + type: + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ObjectMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: describedObject + type: + namedType: io.k8s.api.autoscaling.v2.CrossVersionObjectReference + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2.PodsMetricSource + map: + fields: + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.PodsMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2.ResourceMetricSource + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: target + type: + namedType: io.k8s.api.autoscaling.v2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2.ResourceMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2.MetricValueStatus + default: {} + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: targetAverageUtilization + type: + scalar: numeric + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: currentAverageUtilization + type: + scalar: numeric + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource + map: + fields: + - name: metricName + type: + scalar: string + default: "" + - name: metricSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: targetValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus + map: + fields: + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: currentValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metricName + type: + scalar: string + default: "" + - name: metricSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscaler + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec + default: {} + - name: status + type: + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus + default: {} +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerSpec + map: + fields: + - name: maxReplicas + type: + scalar: numeric + default: 0 + - name: metrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta1.MetricSpec + elementRelationship: atomic + - name: minReplicas + type: + scalar: numeric + - name: scaleTargetRef + type: + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + default: {} +- name: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta1.HorizontalPodAutoscalerCondition + elementRelationship: atomic + - name: currentMetrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta1.MetricStatus + elementRelationship: atomic + - name: currentReplicas + type: + scalar: numeric + default: 0 + - name: desiredReplicas + type: + scalar: numeric + default: 0 + - name: lastScaleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2beta1.MetricSpec + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricSource + - name: external + type: + namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricSource + - name: object + type: + namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricSource + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.MetricStatus + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2beta1.ContainerResourceMetricStatus + - name: external + type: + namedType: io.k8s.api.autoscaling.v2beta1.ExternalMetricStatus + - name: object + type: + namedType: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricSource + map: + fields: + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metricName + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + default: {} + - name: targetValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ObjectMetricStatus + map: + fields: + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: currentValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metricName + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta1.CrossVersionObjectReference + default: {} +- name: io.k8s.api.autoscaling.v2beta1.PodsMetricSource + map: + fields: + - name: metricName + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.PodsMetricStatus + map: + fields: + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metricName + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricSource + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: targetAverageUtilization + type: + scalar: numeric + - name: targetAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta1.ResourceMetricStatus + map: + fields: + - name: currentAverageUtilization + type: + scalar: numeric + - name: currentAverageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus + map: + fields: + - name: container + type: + scalar: string + default: "" + - name: current + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource + map: + fields: + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy + map: + fields: + - name: periodSeconds + type: + scalar: numeric + default: 0 + - name: type + type: + scalar: string + default: "" + - name: value + type: + scalar: numeric + default: 0 +- name: io.k8s.api.autoscaling.v2beta2.HPAScalingRules + map: + fields: + - name: policies + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingPolicy + elementRelationship: atomic + - name: selectPolicy + type: + scalar: string + - name: stabilizationWindowSeconds + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscaler + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec + default: {} + - name: status + type: + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus + default: {} +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior + map: + fields: + - name: scaleDown + type: + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules + - name: scaleUp + type: + namedType: io.k8s.api.autoscaling.v2beta2.HPAScalingRules +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerSpec + map: + fields: + - name: behavior + type: + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerBehavior + - name: maxReplicas + type: + scalar: numeric + default: 0 + - name: metrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.MetricSpec + elementRelationship: atomic + - name: minReplicas + type: + scalar: numeric + - name: scaleTargetRef + type: + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + default: {} +- name: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.HorizontalPodAutoscalerCondition + elementRelationship: atomic + - name: currentMetrics + type: + list: + elementType: + namedType: io.k8s.api.autoscaling.v2beta2.MetricStatus + elementRelationship: atomic + - name: currentReplicas + type: + scalar: numeric + default: 0 + - name: desiredReplicas + type: + scalar: numeric + default: 0 + - name: lastScaleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.autoscaling.v2beta2.MetricSpec + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricSource + - name: external + type: + namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricSource + - name: object + type: + namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricSource + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.MetricStatus + map: + fields: + - name: containerResource + type: + namedType: io.k8s.api.autoscaling.v2beta2.ContainerResourceMetricStatus + - name: external + type: + namedType: io.k8s.api.autoscaling.v2beta2.ExternalMetricStatus + - name: object + type: + namedType: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus + - name: pods + type: + namedType: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus + - name: resource + type: + namedType: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.autoscaling.v2beta2.MetricTarget + map: + fields: + - name: averageUtilization + type: + scalar: numeric + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: type + type: + scalar: string + default: "" + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + map: + fields: + - name: averageUtilization + type: + scalar: numeric + - name: averageValue + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricSource + map: + fields: + - name: describedObject + type: + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ObjectMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: describedObject + type: + namedType: io.k8s.api.autoscaling.v2beta2.CrossVersionObjectReference + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2beta2.PodsMetricSource + map: + fields: + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.PodsMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: metric + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricIdentifier + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricSource + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: target + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricTarget + default: {} +- name: io.k8s.api.autoscaling.v2beta2.ResourceMetricStatus + map: + fields: + - name: current + type: + namedType: io.k8s.api.autoscaling.v2beta2.MetricValueStatus + default: {} + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.batch.v1.CronJob + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.CronJobSpec + default: {} + - name: status + type: + namedType: io.k8s.api.batch.v1.CronJobStatus + default: {} +- name: io.k8s.api.batch.v1.CronJobSpec + map: + fields: + - name: concurrencyPolicy + type: + scalar: string + - name: failedJobsHistoryLimit + type: + scalar: numeric + - name: jobTemplate + type: + namedType: io.k8s.api.batch.v1.JobTemplateSpec + default: {} + - name: schedule + type: + scalar: string + default: "" + - name: startingDeadlineSeconds + type: + scalar: numeric + - name: successfulJobsHistoryLimit + type: + scalar: numeric + - name: suspend + type: + scalar: boolean + - name: timeZone + type: + scalar: string +- name: io.k8s.api.batch.v1.CronJobStatus + map: + fields: + - name: active + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: atomic + - name: lastScheduleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastSuccessfulTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.batch.v1.Job + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.JobSpec + default: {} + - name: status + type: + namedType: io.k8s.api.batch.v1.JobStatus + default: {} +- name: io.k8s.api.batch.v1.JobCondition + map: + fields: + - name: lastProbeTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.batch.v1.JobSpec + map: + fields: + - name: activeDeadlineSeconds + type: + scalar: numeric + - name: backoffLimit + type: + scalar: numeric + - name: backoffLimitPerIndex + type: + scalar: numeric + - name: completionMode + type: + scalar: string + - name: completions + type: + scalar: numeric + - name: managedBy + type: + scalar: string + - name: manualSelector + type: + scalar: boolean + - name: maxFailedIndexes + type: + scalar: numeric + - name: parallelism + type: + scalar: numeric + - name: podFailurePolicy + type: + namedType: io.k8s.api.batch.v1.PodFailurePolicy + - name: podReplacementPolicy + type: + scalar: string + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: successPolicy + type: + namedType: io.k8s.api.batch.v1.SuccessPolicy + - name: suspend + type: + scalar: boolean + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: ttlSecondsAfterFinished + type: + scalar: numeric +- name: io.k8s.api.batch.v1.JobStatus + map: + fields: + - name: active + type: + scalar: numeric + - name: completedIndexes + type: + scalar: string + - name: completionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.batch.v1.JobCondition + elementRelationship: atomic + - name: failed + type: + scalar: numeric + - name: failedIndexes + type: + scalar: string + - name: ready + type: + scalar: numeric + - name: startTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: succeeded + type: + scalar: numeric + - name: terminating + type: + scalar: numeric + - name: uncountedTerminatedPods + type: + namedType: io.k8s.api.batch.v1.UncountedTerminatedPods +- name: io.k8s.api.batch.v1.JobTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.JobSpec + default: {} +- name: io.k8s.api.batch.v1.PodFailurePolicy + map: + fields: + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.batch.v1.PodFailurePolicyRule + elementRelationship: atomic +- name: io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement + map: + fields: + - name: containerName + type: + scalar: string + - name: operator + type: + scalar: string + default: "" + - name: values + type: + list: + elementType: + scalar: numeric + elementRelationship: associative +- name: io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern + map: + fields: + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.batch.v1.PodFailurePolicyRule + map: + fields: + - name: action + type: + scalar: string + default: "" + - name: onExitCodes + type: + namedType: io.k8s.api.batch.v1.PodFailurePolicyOnExitCodesRequirement + - name: onPodConditions + type: + list: + elementType: + namedType: io.k8s.api.batch.v1.PodFailurePolicyOnPodConditionsPattern + elementRelationship: atomic +- name: io.k8s.api.batch.v1.SuccessPolicy + map: + fields: + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.batch.v1.SuccessPolicyRule + elementRelationship: atomic +- name: io.k8s.api.batch.v1.SuccessPolicyRule + map: + fields: + - name: succeededCount + type: + scalar: numeric + - name: succeededIndexes + type: + scalar: string +- name: io.k8s.api.batch.v1.UncountedTerminatedPods + map: + fields: + - name: failed + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: succeeded + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.batch.v1beta1.CronJob + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1beta1.CronJobSpec + default: {} + - name: status + type: + namedType: io.k8s.api.batch.v1beta1.CronJobStatus + default: {} +- name: io.k8s.api.batch.v1beta1.CronJobSpec + map: + fields: + - name: concurrencyPolicy + type: + scalar: string + - name: failedJobsHistoryLimit + type: + scalar: numeric + - name: jobTemplate + type: + namedType: io.k8s.api.batch.v1beta1.JobTemplateSpec + default: {} + - name: schedule + type: + scalar: string + default: "" + - name: startingDeadlineSeconds + type: + scalar: numeric + - name: successfulJobsHistoryLimit + type: + scalar: numeric + - name: suspend + type: + scalar: boolean + - name: timeZone + type: + scalar: string +- name: io.k8s.api.batch.v1beta1.CronJobStatus + map: + fields: + - name: active + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: atomic + - name: lastScheduleTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastSuccessfulTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.batch.v1beta1.JobTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.batch.v1.JobSpec + default: {} +- name: io.k8s.api.certificates.v1.CertificateSigningRequest + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestSpec + default: {} + - name: status + type: + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + default: {} +- name: io.k8s.api.certificates.v1.CertificateSigningRequestCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.certificates.v1.CertificateSigningRequestSpec + map: + fields: + - name: expirationSeconds + type: + scalar: numeric + - name: extra + type: + map: + elementType: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: groups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: request + type: + scalar: string + - name: signerName + type: + scalar: string + default: "" + - name: uid + type: + scalar: string + - name: usages + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: username + type: + scalar: string +- name: io.k8s.api.certificates.v1.CertificateSigningRequestStatus + map: + fields: + - name: certificate + type: + scalar: string + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.certificates.v1.CertificateSigningRequestCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.certificates.v1alpha1.ClusterTrustBundle + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.certificates.v1alpha1.ClusterTrustBundleSpec + default: {} +- name: io.k8s.api.certificates.v1alpha1.ClusterTrustBundleSpec + map: + fields: + - name: signerName + type: + scalar: string + - name: trustBundle + type: + scalar: string + default: "" +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequest + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec + default: {} + - name: status + type: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus + default: {} +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestSpec + map: + fields: + - name: expirationSeconds + type: + scalar: numeric + - name: extra + type: + map: + elementType: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: groups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: request + type: + scalar: string + - name: signerName + type: + scalar: string + - name: uid + type: + scalar: string + - name: usages + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: username + type: + scalar: string +- name: io.k8s.api.certificates.v1beta1.CertificateSigningRequestStatus + map: + fields: + - name: certificate + type: + scalar: string + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.certificates.v1beta1.CertificateSigningRequestCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.certificates.v1beta1.ClusterTrustBundle + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.certificates.v1beta1.ClusterTrustBundleSpec + default: {} +- name: io.k8s.api.certificates.v1beta1.ClusterTrustBundleSpec + map: + fields: + - name: signerName + type: + scalar: string + - name: trustBundle + type: + scalar: string + default: "" +- name: io.k8s.api.coordination.v1.Lease + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1.LeaseSpec + default: {} +- name: io.k8s.api.coordination.v1.LeaseSpec + map: + fields: + - name: acquireTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: holderIdentity + type: + scalar: string + - name: leaseDurationSeconds + type: + scalar: numeric + - name: leaseTransitions + type: + scalar: numeric + - name: preferredHolder + type: + scalar: string + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: strategy + type: + scalar: string +- name: io.k8s.api.coordination.v1alpha2.LeaseCandidate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1alpha2.LeaseCandidateSpec + default: {} +- name: io.k8s.api.coordination.v1alpha2.LeaseCandidateSpec + map: + fields: + - name: binaryVersion + type: + scalar: string + default: "" + - name: emulationVersion + type: + scalar: string + - name: leaseName + type: + scalar: string + default: "" + - name: pingTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: strategy + type: + scalar: string +- name: io.k8s.api.coordination.v1beta1.Lease + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1beta1.LeaseSpec + default: {} +- name: io.k8s.api.coordination.v1beta1.LeaseCandidate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.coordination.v1beta1.LeaseCandidateSpec + default: {} +- name: io.k8s.api.coordination.v1beta1.LeaseCandidateSpec + map: + fields: + - name: binaryVersion + type: + scalar: string + default: "" + - name: emulationVersion + type: + scalar: string + - name: leaseName + type: + scalar: string + default: "" + - name: pingTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: strategy + type: + scalar: string +- name: io.k8s.api.coordination.v1beta1.LeaseSpec + map: + fields: + - name: acquireTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: holderIdentity + type: + scalar: string + - name: leaseDurationSeconds + type: + scalar: numeric + - name: leaseTransitions + type: + scalar: numeric + - name: preferredHolder + type: + scalar: string + - name: renewTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: strategy + type: + scalar: string +- name: io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: partition + type: + scalar: numeric + - name: readOnly + type: + scalar: boolean + - name: volumeID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.Affinity + map: + fields: + - name: nodeAffinity + type: + namedType: io.k8s.api.core.v1.NodeAffinity + - name: podAffinity + type: + namedType: io.k8s.api.core.v1.PodAffinity + - name: podAntiAffinity + type: + namedType: io.k8s.api.core.v1.PodAntiAffinity +- name: io.k8s.api.core.v1.AppArmorProfile + map: + fields: + - name: localhostProfile + type: + scalar: string + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: localhostProfile + discriminatorValue: LocalhostProfile +- name: io.k8s.api.core.v1.AttachedVolume + map: + fields: + - name: devicePath + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.AzureDiskVolumeSource + map: + fields: + - name: cachingMode + type: + scalar: string + default: ReadWrite + - name: diskName + type: + scalar: string + default: "" + - name: diskURI + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + default: ext4 + - name: kind + type: + scalar: string + default: Shared + - name: readOnly + type: + scalar: boolean + default: false +- name: io.k8s.api.core.v1.AzureFilePersistentVolumeSource + map: + fields: + - name: readOnly + type: + scalar: boolean + - name: secretName + type: + scalar: string + default: "" + - name: secretNamespace + type: + scalar: string + - name: shareName + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.AzureFileVolumeSource + map: + fields: + - name: readOnly + type: + scalar: boolean + - name: secretName + type: + scalar: string + default: "" + - name: shareName + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.CSIPersistentVolumeSource + map: + fields: + - name: controllerExpandSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: controllerPublishSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: nodeExpandSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: nodePublishSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: nodeStageSecretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: readOnly + type: + scalar: boolean + - name: volumeAttributes + type: + map: + elementType: + scalar: string + - name: volumeHandle + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.CSIVolumeSource + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: nodePublishSecretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: readOnly + type: + scalar: boolean + - name: volumeAttributes + type: + map: + elementType: + scalar: string +- name: io.k8s.api.core.v1.Capabilities + map: + fields: + - name: add + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: drop + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.CephFSPersistentVolumeSource + map: + fields: + - name: monitors + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: path + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretFile + type: + scalar: string + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: user + type: + scalar: string +- name: io.k8s.api.core.v1.CephFSVolumeSource + map: + fields: + - name: monitors + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: path + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretFile + type: + scalar: string + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: user + type: + scalar: string +- name: io.k8s.api.core.v1.CinderPersistentVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: volumeID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.CinderVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: volumeID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ClientIPConfig + map: + fields: + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.core.v1.ClusterTrustBundleProjection + map: + fields: + - name: labelSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: name + type: + scalar: string + - name: optional + type: + scalar: boolean + - name: path + type: + scalar: string + default: "" + - name: signerName + type: + scalar: string +- name: io.k8s.api.core.v1.ComponentCondition + map: + fields: + - name: error + type: + scalar: string + - name: message + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ComponentStatus + map: + fields: + - name: apiVersion + type: + scalar: string + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ComponentCondition + elementRelationship: associative + keys: + - type + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} +- name: io.k8s.api.core.v1.ConfigMap + map: + fields: + - name: apiVersion + type: + scalar: string + - name: binaryData + type: + map: + elementType: + scalar: string + - name: data + type: + map: + elementType: + scalar: string + - name: immutable + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} +- name: io.k8s.api.core.v1.ConfigMapEnvSource + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean +- name: io.k8s.api.core.v1.ConfigMapKeySelector + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean + elementRelationship: atomic +- name: io.k8s.api.core.v1.ConfigMapNodeConfigSource + map: + fields: + - name: kubeletConfigKey + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" + - name: resourceVersion + type: + scalar: string + - name: uid + type: + scalar: string +- name: io.k8s.api.core.v1.ConfigMapProjection + map: + fields: + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.KeyToPath + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean +- name: io.k8s.api.core.v1.ConfigMapVolumeSource + map: + fields: + - name: defaultMode + type: + scalar: numeric + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.KeyToPath + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean +- name: io.k8s.api.core.v1.Container + map: + fields: + - name: args + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: command + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: env + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EnvVar + elementRelationship: associative + keys: + - name + - name: envFrom + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EnvFromSource + elementRelationship: atomic + - name: image + type: + scalar: string + - name: imagePullPolicy + type: + scalar: string + - name: lifecycle + type: + namedType: io.k8s.api.core.v1.Lifecycle + - name: livenessProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: name + type: + scalar: string + default: "" + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerPort + elementRelationship: associative + keys: + - containerPort + - protocol + - name: readinessProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: resizePolicy + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerResizePolicy + elementRelationship: atomic + - name: resources + type: + namedType: io.k8s.api.core.v1.ResourceRequirements + default: {} + - name: restartPolicy + type: + scalar: string + - name: securityContext + type: + namedType: io.k8s.api.core.v1.SecurityContext + - name: startupProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: stdin + type: + scalar: boolean + - name: stdinOnce + type: + scalar: boolean + - name: terminationMessagePath + type: + scalar: string + - name: terminationMessagePolicy + type: + scalar: string + - name: tty + type: + scalar: boolean + - name: volumeDevices + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeDevice + elementRelationship: associative + keys: + - devicePath + - name: volumeMounts + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeMount + elementRelationship: associative + keys: + - mountPath + - name: workingDir + type: + scalar: string +- name: io.k8s.api.core.v1.ContainerImage + map: + fields: + - name: names + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: sizeBytes + type: + scalar: numeric +- name: io.k8s.api.core.v1.ContainerPort + map: + fields: + - name: containerPort + type: + scalar: numeric + default: 0 + - name: hostIP + type: + scalar: string + - name: hostPort + type: + scalar: numeric + - name: name + type: + scalar: string + - name: protocol + type: + scalar: string + default: TCP +- name: io.k8s.api.core.v1.ContainerResizePolicy + map: + fields: + - name: resourceName + type: + scalar: string + default: "" + - name: restartPolicy + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ContainerState + map: + fields: + - name: running + type: + namedType: io.k8s.api.core.v1.ContainerStateRunning + - name: terminated + type: + namedType: io.k8s.api.core.v1.ContainerStateTerminated + - name: waiting + type: + namedType: io.k8s.api.core.v1.ContainerStateWaiting +- name: io.k8s.api.core.v1.ContainerStateRunning + map: + fields: + - name: startedAt + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.core.v1.ContainerStateTerminated + map: + fields: + - name: containerID + type: + scalar: string + - name: exitCode + type: + scalar: numeric + default: 0 + - name: finishedAt + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: signal + type: + scalar: numeric + - name: startedAt + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.core.v1.ContainerStateWaiting + map: + fields: + - name: message + type: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.core.v1.ContainerStatus + map: + fields: + - name: allocatedResources + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: allocatedResourcesStatus + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ResourceStatus + elementRelationship: associative + keys: + - name + - name: containerID + type: + scalar: string + - name: image + type: + scalar: string + default: "" + - name: imageID + type: + scalar: string + default: "" + - name: lastState + type: + namedType: io.k8s.api.core.v1.ContainerState + default: {} + - name: name + type: + scalar: string + default: "" + - name: ready + type: + scalar: boolean + default: false + - name: resources + type: + namedType: io.k8s.api.core.v1.ResourceRequirements + - name: restartCount + type: + scalar: numeric + default: 0 + - name: started + type: + scalar: boolean + - name: state + type: + namedType: io.k8s.api.core.v1.ContainerState + default: {} + - name: stopSignal + type: + scalar: string + - name: user + type: + namedType: io.k8s.api.core.v1.ContainerUser + - name: volumeMounts + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeMountStatus + elementRelationship: associative + keys: + - mountPath +- name: io.k8s.api.core.v1.ContainerUser + map: + fields: + - name: linux + type: + namedType: io.k8s.api.core.v1.LinuxContainerUser +- name: io.k8s.api.core.v1.DaemonEndpoint + map: + fields: + - name: Port + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.DownwardAPIProjection + map: + fields: + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.DownwardAPIVolumeFile + elementRelationship: atomic +- name: io.k8s.api.core.v1.DownwardAPIVolumeFile + map: + fields: + - name: fieldRef + type: + namedType: io.k8s.api.core.v1.ObjectFieldSelector + - name: mode + type: + scalar: numeric + - name: path + type: + scalar: string + default: "" + - name: resourceFieldRef + type: + namedType: io.k8s.api.core.v1.ResourceFieldSelector +- name: io.k8s.api.core.v1.DownwardAPIVolumeSource + map: + fields: + - name: defaultMode + type: + scalar: numeric + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.DownwardAPIVolumeFile + elementRelationship: atomic +- name: io.k8s.api.core.v1.EmptyDirVolumeSource + map: + fields: + - name: medium + type: + scalar: string + - name: sizeLimit + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.core.v1.EndpointAddress + map: + fields: + - name: hostname + type: + scalar: string + - name: ip + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + - name: targetRef + type: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: atomic +- name: io.k8s.api.core.v1.EndpointPort + map: + fields: + - name: appProtocol + type: + scalar: string + - name: name + type: + scalar: string + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.EndpointSubset + map: + fields: + - name: addresses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EndpointAddress + elementRelationship: atomic + - name: notReadyAddresses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EndpointAddress + elementRelationship: atomic + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EndpointPort + elementRelationship: atomic +- name: io.k8s.api.core.v1.Endpoints + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: subsets + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EndpointSubset + elementRelationship: atomic +- name: io.k8s.api.core.v1.EnvFromSource + map: + fields: + - name: configMapRef + type: + namedType: io.k8s.api.core.v1.ConfigMapEnvSource + - name: prefix + type: + scalar: string + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretEnvSource +- name: io.k8s.api.core.v1.EnvVar + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: value + type: + scalar: string + - name: valueFrom + type: + namedType: io.k8s.api.core.v1.EnvVarSource +- name: io.k8s.api.core.v1.EnvVarSource + map: + fields: + - name: configMapKeyRef + type: + namedType: io.k8s.api.core.v1.ConfigMapKeySelector + - name: fieldRef + type: + namedType: io.k8s.api.core.v1.ObjectFieldSelector + - name: resourceFieldRef + type: + namedType: io.k8s.api.core.v1.ResourceFieldSelector + - name: secretKeyRef + type: + namedType: io.k8s.api.core.v1.SecretKeySelector +- name: io.k8s.api.core.v1.EphemeralContainer + map: + fields: + - name: args + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: command + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: env + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EnvVar + elementRelationship: associative + keys: + - name + - name: envFrom + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EnvFromSource + elementRelationship: atomic + - name: image + type: + scalar: string + - name: imagePullPolicy + type: + scalar: string + - name: lifecycle + type: + namedType: io.k8s.api.core.v1.Lifecycle + - name: livenessProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: name + type: + scalar: string + default: "" + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerPort + elementRelationship: associative + keys: + - containerPort + - protocol + - name: readinessProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: resizePolicy + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerResizePolicy + elementRelationship: atomic + - name: resources + type: + namedType: io.k8s.api.core.v1.ResourceRequirements + default: {} + - name: restartPolicy + type: + scalar: string + - name: securityContext + type: + namedType: io.k8s.api.core.v1.SecurityContext + - name: startupProbe + type: + namedType: io.k8s.api.core.v1.Probe + - name: stdin + type: + scalar: boolean + - name: stdinOnce + type: + scalar: boolean + - name: targetContainerName + type: + scalar: string + - name: terminationMessagePath + type: + scalar: string + - name: terminationMessagePolicy + type: + scalar: string + - name: tty + type: + scalar: boolean + - name: volumeDevices + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeDevice + elementRelationship: associative + keys: + - devicePath + - name: volumeMounts + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeMount + elementRelationship: associative + keys: + - mountPath + - name: workingDir + type: + scalar: string +- name: io.k8s.api.core.v1.EphemeralVolumeSource + map: + fields: + - name: volumeClaimTemplate + type: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimTemplate +- name: io.k8s.api.core.v1.Event + map: + fields: + - name: action + type: + scalar: string + - name: apiVersion + type: + scalar: string + - name: count + type: + scalar: numeric + - name: eventTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: firstTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: involvedObject + type: + namedType: io.k8s.api.core.v1.ObjectReference + default: {} + - name: kind + type: + scalar: string + - name: lastTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: reason + type: + scalar: string + - name: related + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: reportingComponent + type: + scalar: string + default: "" + - name: reportingInstance + type: + scalar: string + default: "" + - name: series + type: + namedType: io.k8s.api.core.v1.EventSeries + - name: source + type: + namedType: io.k8s.api.core.v1.EventSource + default: {} + - name: type + type: + scalar: string +- name: io.k8s.api.core.v1.EventSeries + map: + fields: + - name: count + type: + scalar: numeric + - name: lastObservedTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime +- name: io.k8s.api.core.v1.EventSource + map: + fields: + - name: component + type: + scalar: string + - name: host + type: + scalar: string +- name: io.k8s.api.core.v1.ExecAction + map: + fields: + - name: command + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.FCVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: lun + type: + scalar: numeric + - name: readOnly + type: + scalar: boolean + - name: targetWWNs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: wwids + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.FlexPersistentVolumeSource + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: options + type: + map: + elementType: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference +- name: io.k8s.api.core.v1.FlexVolumeSource + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: fsType + type: + scalar: string + - name: options + type: + map: + elementType: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference +- name: io.k8s.api.core.v1.FlockerVolumeSource + map: + fields: + - name: datasetName + type: + scalar: string + - name: datasetUUID + type: + scalar: string +- name: io.k8s.api.core.v1.GCEPersistentDiskVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: partition + type: + scalar: numeric + - name: pdName + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean +- name: io.k8s.api.core.v1.GRPCAction + map: + fields: + - name: port + type: + scalar: numeric + default: 0 + - name: service + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.GitRepoVolumeSource + map: + fields: + - name: directory + type: + scalar: string + - name: repository + type: + scalar: string + default: "" + - name: revision + type: + scalar: string +- name: io.k8s.api.core.v1.GlusterfsPersistentVolumeSource + map: + fields: + - name: endpoints + type: + scalar: string + default: "" + - name: endpointsNamespace + type: + scalar: string + - name: path + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean +- name: io.k8s.api.core.v1.GlusterfsVolumeSource + map: + fields: + - name: endpoints + type: + scalar: string + default: "" + - name: path + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean +- name: io.k8s.api.core.v1.HTTPGetAction + map: + fields: + - name: host + type: + scalar: string + - name: httpHeaders + type: + list: + elementType: + namedType: io.k8s.api.core.v1.HTTPHeader + elementRelationship: atomic + - name: path + type: + scalar: string + - name: port + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: scheme + type: + scalar: string +- name: io.k8s.api.core.v1.HTTPHeader + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: value + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.HostAlias + map: + fields: + - name: hostnames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: ip + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.HostIP + map: + fields: + - name: ip + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.HostPathVolumeSource + map: + fields: + - name: path + type: + scalar: string + default: "" + - name: type + type: + scalar: string +- name: io.k8s.api.core.v1.ISCSIPersistentVolumeSource + map: + fields: + - name: chapAuthDiscovery + type: + scalar: boolean + - name: chapAuthSession + type: + scalar: boolean + - name: fsType + type: + scalar: string + - name: initiatorName + type: + scalar: string + - name: iqn + type: + scalar: string + default: "" + - name: iscsiInterface + type: + scalar: string + default: default + - name: lun + type: + scalar: numeric + default: 0 + - name: portals + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: targetPortal + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ISCSIVolumeSource + map: + fields: + - name: chapAuthDiscovery + type: + scalar: boolean + - name: chapAuthSession + type: + scalar: boolean + - name: fsType + type: + scalar: string + - name: initiatorName + type: + scalar: string + - name: iqn + type: + scalar: string + default: "" + - name: iscsiInterface + type: + scalar: string + default: default + - name: lun + type: + scalar: numeric + default: 0 + - name: portals + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: targetPortal + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ImageVolumeSource + map: + fields: + - name: pullPolicy + type: + scalar: string + - name: reference + type: + scalar: string +- name: io.k8s.api.core.v1.KeyToPath + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: mode + type: + scalar: numeric + - name: path + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.Lifecycle + map: + fields: + - name: postStart + type: + namedType: io.k8s.api.core.v1.LifecycleHandler + - name: preStop + type: + namedType: io.k8s.api.core.v1.LifecycleHandler + - name: stopSignal + type: + scalar: string +- name: io.k8s.api.core.v1.LifecycleHandler + map: + fields: + - name: exec + type: + namedType: io.k8s.api.core.v1.ExecAction + - name: httpGet + type: + namedType: io.k8s.api.core.v1.HTTPGetAction + - name: sleep + type: + namedType: io.k8s.api.core.v1.SleepAction + - name: tcpSocket + type: + namedType: io.k8s.api.core.v1.TCPSocketAction +- name: io.k8s.api.core.v1.LimitRange + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.LimitRangeSpec + default: {} +- name: io.k8s.api.core.v1.LimitRangeItem + map: + fields: + - name: default + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: defaultRequest + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: max + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: maxLimitRequestRatio + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: min + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.LimitRangeSpec + map: + fields: + - name: limits + type: + list: + elementType: + namedType: io.k8s.api.core.v1.LimitRangeItem + elementRelationship: atomic +- name: io.k8s.api.core.v1.LinuxContainerUser + map: + fields: + - name: gid + type: + scalar: numeric + default: 0 + - name: supplementalGroups + type: + list: + elementType: + scalar: numeric + elementRelationship: atomic + - name: uid + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.LoadBalancerIngress + map: + fields: + - name: hostname + type: + scalar: string + - name: ip + type: + scalar: string + - name: ipMode + type: + scalar: string + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PortStatus + elementRelationship: atomic +- name: io.k8s.api.core.v1.LoadBalancerStatus + map: + fields: + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.core.v1.LoadBalancerIngress + elementRelationship: atomic +- name: io.k8s.api.core.v1.LocalObjectReference + map: + fields: + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.core.v1.LocalVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: path + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ModifyVolumeStatus + map: + fields: + - name: status + type: + scalar: string + default: "" + - name: targetVolumeAttributesClassName + type: + scalar: string +- name: io.k8s.api.core.v1.NFSVolumeSource + map: + fields: + - name: path + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean + - name: server + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.Namespace + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.NamespaceSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.NamespaceStatus + default: {} +- name: io.k8s.api.core.v1.NamespaceCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.NamespaceSpec + map: + fields: + - name: finalizers + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.NamespaceStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NamespaceCondition + elementRelationship: associative + keys: + - type + - name: phase + type: + scalar: string +- name: io.k8s.api.core.v1.Node + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.NodeSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.NodeStatus + default: {} +- name: io.k8s.api.core.v1.NodeAddress + map: + fields: + - name: address + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.NodeAffinity + map: + fields: + - name: preferredDuringSchedulingIgnoredDuringExecution + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PreferredSchedulingTerm + elementRelationship: atomic + - name: requiredDuringSchedulingIgnoredDuringExecution + type: + namedType: io.k8s.api.core.v1.NodeSelector +- name: io.k8s.api.core.v1.NodeCondition + map: + fields: + - name: lastHeartbeatTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.NodeConfigSource + map: + fields: + - name: configMap + type: + namedType: io.k8s.api.core.v1.ConfigMapNodeConfigSource +- name: io.k8s.api.core.v1.NodeConfigStatus + map: + fields: + - name: active + type: + namedType: io.k8s.api.core.v1.NodeConfigSource + - name: assigned + type: + namedType: io.k8s.api.core.v1.NodeConfigSource + - name: error + type: + scalar: string + - name: lastKnownGood + type: + namedType: io.k8s.api.core.v1.NodeConfigSource +- name: io.k8s.api.core.v1.NodeDaemonEndpoints + map: + fields: + - name: kubeletEndpoint + type: + namedType: io.k8s.api.core.v1.DaemonEndpoint + default: {} +- name: io.k8s.api.core.v1.NodeFeatures + map: + fields: + - name: supplementalGroupsPolicy + type: + scalar: boolean +- name: io.k8s.api.core.v1.NodeRuntimeHandler + map: + fields: + - name: features + type: + namedType: io.k8s.api.core.v1.NodeRuntimeHandlerFeatures + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.NodeRuntimeHandlerFeatures + map: + fields: + - name: recursiveReadOnlyMounts + type: + scalar: boolean + - name: userNamespaces + type: + scalar: boolean +- name: io.k8s.api.core.v1.NodeSelector + map: + fields: + - name: nodeSelectorTerms + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeSelectorTerm + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.core.v1.NodeSelectorRequirement + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: operator + type: + scalar: string + default: "" + - name: values + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.NodeSelectorTerm + map: + fields: + - name: matchExpressions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeSelectorRequirement + elementRelationship: atomic + - name: matchFields + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeSelectorRequirement + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.core.v1.NodeSpec + map: + fields: + - name: configSource + type: + namedType: io.k8s.api.core.v1.NodeConfigSource + - name: externalID + type: + scalar: string + - name: podCIDR + type: + scalar: string + - name: podCIDRs + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: providerID + type: + scalar: string + - name: taints + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Taint + elementRelationship: atomic + - name: unschedulable + type: + scalar: boolean +- name: io.k8s.api.core.v1.NodeStatus + map: + fields: + - name: addresses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeAddress + elementRelationship: associative + keys: + - type + - name: allocatable + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: capacity + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeCondition + elementRelationship: associative + keys: + - type + - name: config + type: + namedType: io.k8s.api.core.v1.NodeConfigStatus + - name: daemonEndpoints + type: + namedType: io.k8s.api.core.v1.NodeDaemonEndpoints + default: {} + - name: features + type: + namedType: io.k8s.api.core.v1.NodeFeatures + - name: images + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerImage + elementRelationship: atomic + - name: nodeInfo + type: + namedType: io.k8s.api.core.v1.NodeSystemInfo + default: {} + - name: phase + type: + scalar: string + - name: runtimeHandlers + type: + list: + elementType: + namedType: io.k8s.api.core.v1.NodeRuntimeHandler + elementRelationship: atomic + - name: volumesAttached + type: + list: + elementType: + namedType: io.k8s.api.core.v1.AttachedVolume + elementRelationship: atomic + - name: volumesInUse + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.NodeSwapStatus + map: + fields: + - name: capacity + type: + scalar: numeric +- name: io.k8s.api.core.v1.NodeSystemInfo + map: + fields: + - name: architecture + type: + scalar: string + default: "" + - name: bootID + type: + scalar: string + default: "" + - name: containerRuntimeVersion + type: + scalar: string + default: "" + - name: kernelVersion + type: + scalar: string + default: "" + - name: kubeProxyVersion + type: + scalar: string + default: "" + - name: kubeletVersion + type: + scalar: string + default: "" + - name: machineID + type: + scalar: string + default: "" + - name: operatingSystem + type: + scalar: string + default: "" + - name: osImage + type: + scalar: string + default: "" + - name: swap + type: + namedType: io.k8s.api.core.v1.NodeSwapStatus + - name: systemUUID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ObjectFieldSelector + map: + fields: + - name: apiVersion + type: + scalar: string + - name: fieldPath + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.core.v1.ObjectReference + map: + fields: + - name: apiVersion + type: + scalar: string + - name: fieldPath + type: + scalar: string + - name: kind + type: + scalar: string + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: resourceVersion + type: + scalar: string + - name: uid + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.PersistentVolume + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.PersistentVolumeStatus + default: {} +- name: io.k8s.api.core.v1.PersistentVolumeClaim + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimStatus + default: {} +- name: io.k8s.api.core.v1.PersistentVolumeClaimCondition + map: + fields: + - name: lastProbeTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PersistentVolumeClaimSpec + map: + fields: + - name: accessModes + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: dataSource + type: + namedType: io.k8s.api.core.v1.TypedLocalObjectReference + - name: dataSourceRef + type: + namedType: io.k8s.api.core.v1.TypedObjectReference + - name: resources + type: + namedType: io.k8s.api.core.v1.VolumeResourceRequirements + default: {} + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: storageClassName + type: + scalar: string + - name: volumeAttributesClassName + type: + scalar: string + - name: volumeMode + type: + scalar: string + - name: volumeName + type: + scalar: string +- name: io.k8s.api.core.v1.PersistentVolumeClaimStatus + map: + fields: + - name: accessModes + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: allocatedResourceStatuses + type: + map: + elementType: + scalar: string + elementRelationship: separable + - name: allocatedResources + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: capacity + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimCondition + elementRelationship: associative + keys: + - type + - name: currentVolumeAttributesClassName + type: + scalar: string + - name: modifyVolumeStatus + type: + namedType: io.k8s.api.core.v1.ModifyVolumeStatus + - name: phase + type: + scalar: string +- name: io.k8s.api.core.v1.PersistentVolumeClaimTemplate + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimSpec + default: {} +- name: io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource + map: + fields: + - name: claimName + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean +- name: io.k8s.api.core.v1.PersistentVolumeSpec + map: + fields: + - name: accessModes + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: awsElasticBlockStore + type: + namedType: io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource + - name: azureDisk + type: + namedType: io.k8s.api.core.v1.AzureDiskVolumeSource + - name: azureFile + type: + namedType: io.k8s.api.core.v1.AzureFilePersistentVolumeSource + - name: capacity + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: cephfs + type: + namedType: io.k8s.api.core.v1.CephFSPersistentVolumeSource + - name: cinder + type: + namedType: io.k8s.api.core.v1.CinderPersistentVolumeSource + - name: claimRef + type: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: separable + - name: csi + type: + namedType: io.k8s.api.core.v1.CSIPersistentVolumeSource + - name: fc + type: + namedType: io.k8s.api.core.v1.FCVolumeSource + - name: flexVolume + type: + namedType: io.k8s.api.core.v1.FlexPersistentVolumeSource + - name: flocker + type: + namedType: io.k8s.api.core.v1.FlockerVolumeSource + - name: gcePersistentDisk + type: + namedType: io.k8s.api.core.v1.GCEPersistentDiskVolumeSource + - name: glusterfs + type: + namedType: io.k8s.api.core.v1.GlusterfsPersistentVolumeSource + - name: hostPath + type: + namedType: io.k8s.api.core.v1.HostPathVolumeSource + - name: iscsi + type: + namedType: io.k8s.api.core.v1.ISCSIPersistentVolumeSource + - name: local + type: + namedType: io.k8s.api.core.v1.LocalVolumeSource + - name: mountOptions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: nfs + type: + namedType: io.k8s.api.core.v1.NFSVolumeSource + - name: nodeAffinity + type: + namedType: io.k8s.api.core.v1.VolumeNodeAffinity + - name: persistentVolumeReclaimPolicy + type: + scalar: string + - name: photonPersistentDisk + type: + namedType: io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource + - name: portworxVolume + type: + namedType: io.k8s.api.core.v1.PortworxVolumeSource + - name: quobyte + type: + namedType: io.k8s.api.core.v1.QuobyteVolumeSource + - name: rbd + type: + namedType: io.k8s.api.core.v1.RBDPersistentVolumeSource + - name: scaleIO + type: + namedType: io.k8s.api.core.v1.ScaleIOPersistentVolumeSource + - name: storageClassName + type: + scalar: string + - name: storageos + type: + namedType: io.k8s.api.core.v1.StorageOSPersistentVolumeSource + - name: volumeAttributesClassName + type: + scalar: string + - name: volumeMode + type: + scalar: string + - name: vsphereVolume + type: + namedType: io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource +- name: io.k8s.api.core.v1.PersistentVolumeStatus + map: + fields: + - name: lastPhaseTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: phase + type: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: pdID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.Pod + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.PodSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.PodStatus + default: {} +- name: io.k8s.api.core.v1.PodAffinity + map: + fields: + - name: preferredDuringSchedulingIgnoredDuringExecution + type: + list: + elementType: + namedType: io.k8s.api.core.v1.WeightedPodAffinityTerm + elementRelationship: atomic + - name: requiredDuringSchedulingIgnoredDuringExecution + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodAffinityTerm + elementRelationship: atomic +- name: io.k8s.api.core.v1.PodAffinityTerm + map: + fields: + - name: labelSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: matchLabelKeys + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: mismatchLabelKeys + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: namespaces + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: topologyKey + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodAntiAffinity + map: + fields: + - name: preferredDuringSchedulingIgnoredDuringExecution + type: + list: + elementType: + namedType: io.k8s.api.core.v1.WeightedPodAffinityTerm + elementRelationship: atomic + - name: requiredDuringSchedulingIgnoredDuringExecution + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodAffinityTerm + elementRelationship: atomic +- name: io.k8s.api.core.v1.PodCondition + map: + fields: + - name: lastProbeTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodDNSConfig + map: + fields: + - name: nameservers + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: options + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodDNSConfigOption + elementRelationship: atomic + - name: searches + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.PodDNSConfigOption + map: + fields: + - name: name + type: + scalar: string + - name: value + type: + scalar: string +- name: io.k8s.api.core.v1.PodIP + map: + fields: + - name: ip + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodOS + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodReadinessGate + map: + fields: + - name: conditionType + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodResourceClaim + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: resourceClaimName + type: + scalar: string + - name: resourceClaimTemplateName + type: + scalar: string +- name: io.k8s.api.core.v1.PodResourceClaimStatus + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: resourceClaimName + type: + scalar: string +- name: io.k8s.api.core.v1.PodSchedulingGate + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PodSecurityContext + map: + fields: + - name: appArmorProfile + type: + namedType: io.k8s.api.core.v1.AppArmorProfile + - name: fsGroup + type: + scalar: numeric + - name: fsGroupChangePolicy + type: + scalar: string + - name: runAsGroup + type: + scalar: numeric + - name: runAsNonRoot + type: + scalar: boolean + - name: runAsUser + type: + scalar: numeric + - name: seLinuxChangePolicy + type: + scalar: string + - name: seLinuxOptions + type: + namedType: io.k8s.api.core.v1.SELinuxOptions + - name: seccompProfile + type: + namedType: io.k8s.api.core.v1.SeccompProfile + - name: supplementalGroups + type: + list: + elementType: + scalar: numeric + elementRelationship: atomic + - name: supplementalGroupsPolicy + type: + scalar: string + - name: sysctls + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Sysctl + elementRelationship: atomic + - name: windowsOptions + type: + namedType: io.k8s.api.core.v1.WindowsSecurityContextOptions +- name: io.k8s.api.core.v1.PodSpec + map: + fields: + - name: activeDeadlineSeconds + type: + scalar: numeric + - name: affinity + type: + namedType: io.k8s.api.core.v1.Affinity + - name: automountServiceAccountToken + type: + scalar: boolean + - name: containers + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Container + elementRelationship: associative + keys: + - name + - name: dnsConfig + type: + namedType: io.k8s.api.core.v1.PodDNSConfig + - name: dnsPolicy + type: + scalar: string + - name: enableServiceLinks + type: + scalar: boolean + - name: ephemeralContainers + type: + list: + elementType: + namedType: io.k8s.api.core.v1.EphemeralContainer + elementRelationship: associative + keys: + - name + - name: hostAliases + type: + list: + elementType: + namedType: io.k8s.api.core.v1.HostAlias + elementRelationship: associative + keys: + - ip + - name: hostIPC + type: + scalar: boolean + - name: hostNetwork + type: + scalar: boolean + - name: hostPID + type: + scalar: boolean + - name: hostUsers + type: + scalar: boolean + - name: hostname + type: + scalar: string + - name: imagePullSecrets + type: + list: + elementType: + namedType: io.k8s.api.core.v1.LocalObjectReference + elementRelationship: associative + keys: + - name + - name: initContainers + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Container + elementRelationship: associative + keys: + - name + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: os + type: + namedType: io.k8s.api.core.v1.PodOS + - name: overhead + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: preemptionPolicy + type: + scalar: string + - name: priority + type: + scalar: numeric + - name: priorityClassName + type: + scalar: string + - name: readinessGates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodReadinessGate + elementRelationship: atomic + - name: resourceClaims + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodResourceClaim + elementRelationship: associative + keys: + - name + - name: resources + type: + namedType: io.k8s.api.core.v1.ResourceRequirements + - name: restartPolicy + type: + scalar: string + - name: runtimeClassName + type: + scalar: string + - name: schedulerName + type: + scalar: string + - name: schedulingGates + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodSchedulingGate + elementRelationship: associative + keys: + - name + - name: securityContext + type: + namedType: io.k8s.api.core.v1.PodSecurityContext + - name: serviceAccount + type: + scalar: string + - name: serviceAccountName + type: + scalar: string + - name: setHostnameAsFQDN + type: + scalar: boolean + - name: shareProcessNamespace + type: + scalar: boolean + - name: subdomain + type: + scalar: string + - name: terminationGracePeriodSeconds + type: + scalar: numeric + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic + - name: topologySpreadConstraints + type: + list: + elementType: + namedType: io.k8s.api.core.v1.TopologySpreadConstraint + elementRelationship: associative + keys: + - topologyKey + - whenUnsatisfiable + - name: volumes + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Volume + elementRelationship: associative + keys: + - name +- name: io.k8s.api.core.v1.PodStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodCondition + elementRelationship: associative + keys: + - type + - name: containerStatuses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerStatus + elementRelationship: atomic + - name: ephemeralContainerStatuses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerStatus + elementRelationship: atomic + - name: hostIP + type: + scalar: string + - name: hostIPs + type: + list: + elementType: + namedType: io.k8s.api.core.v1.HostIP + elementRelationship: atomic + - name: initContainerStatuses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ContainerStatus + elementRelationship: atomic + - name: message + type: + scalar: string + - name: nominatedNodeName + type: + scalar: string + - name: observedGeneration + type: + scalar: numeric + - name: phase + type: + scalar: string + - name: podIP + type: + scalar: string + - name: podIPs + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodIP + elementRelationship: associative + keys: + - ip + - name: qosClass + type: + scalar: string + - name: reason + type: + scalar: string + - name: resize + type: + scalar: string + - name: resourceClaimStatuses + type: + list: + elementType: + namedType: io.k8s.api.core.v1.PodResourceClaimStatus + elementRelationship: associative + keys: + - name + - name: startTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.core.v1.PodTemplate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.core.v1.PodTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.PodSpec + default: {} +- name: io.k8s.api.core.v1.PortStatus + map: + fields: + - name: error + type: + scalar: string + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PortworxVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: volumeID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.PreferredSchedulingTerm + map: + fields: + - name: preference + type: + namedType: io.k8s.api.core.v1.NodeSelectorTerm + default: {} + - name: weight + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.Probe + map: + fields: + - name: exec + type: + namedType: io.k8s.api.core.v1.ExecAction + - name: failureThreshold + type: + scalar: numeric + - name: grpc + type: + namedType: io.k8s.api.core.v1.GRPCAction + - name: httpGet + type: + namedType: io.k8s.api.core.v1.HTTPGetAction + - name: initialDelaySeconds + type: + scalar: numeric + - name: periodSeconds + type: + scalar: numeric + - name: successThreshold + type: + scalar: numeric + - name: tcpSocket + type: + namedType: io.k8s.api.core.v1.TCPSocketAction + - name: terminationGracePeriodSeconds + type: + scalar: numeric + - name: timeoutSeconds + type: + scalar: numeric +- name: io.k8s.api.core.v1.ProjectedVolumeSource + map: + fields: + - name: defaultMode + type: + scalar: numeric + - name: sources + type: + list: + elementType: + namedType: io.k8s.api.core.v1.VolumeProjection + elementRelationship: atomic +- name: io.k8s.api.core.v1.QuobyteVolumeSource + map: + fields: + - name: group + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: registry + type: + scalar: string + default: "" + - name: tenant + type: + scalar: string + - name: user + type: + scalar: string + - name: volume + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.RBDPersistentVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: image + type: + scalar: string + default: "" + - name: keyring + type: + scalar: string + default: /etc/ceph/keyring + - name: monitors + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: pool + type: + scalar: string + default: rbd + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: user + type: + scalar: string + default: admin +- name: io.k8s.api.core.v1.RBDVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: image + type: + scalar: string + default: "" + - name: keyring + type: + scalar: string + default: /etc/ceph/keyring + - name: monitors + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: pool + type: + scalar: string + default: rbd + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: user + type: + scalar: string + default: admin +- name: io.k8s.api.core.v1.ReplicationController + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.ReplicationControllerSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.ReplicationControllerStatus + default: {} +- name: io.k8s.api.core.v1.ReplicationControllerCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ReplicationControllerSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + default: 0 + - name: replicas + type: + scalar: numeric + default: 1 + - name: selector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec +- name: io.k8s.api.core.v1.ReplicationControllerStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ReplicationControllerCondition + elementRelationship: associative + keys: + - type + - name: fullyLabeledReplicas + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.ResourceClaim + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: request + type: + scalar: string +- name: io.k8s.api.core.v1.ResourceFieldSelector + map: + fields: + - name: containerName + type: + scalar: string + - name: divisor + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: resource + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.core.v1.ResourceHealth + map: + fields: + - name: health + type: + scalar: string + - name: resourceID + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ResourceQuota + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.ResourceQuotaSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.ResourceQuotaStatus + default: {} +- name: io.k8s.api.core.v1.ResourceQuotaSpec + map: + fields: + - name: hard + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: scopeSelector + type: + namedType: io.k8s.api.core.v1.ScopeSelector + - name: scopes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.ResourceQuotaStatus + map: + fields: + - name: hard + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: used + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.core.v1.ResourceRequirements + map: + fields: + - name: claims + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ResourceClaim + elementRelationship: associative + keys: + - name + - name: limits + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: requests + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.core.v1.ResourceStatus + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: resources + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ResourceHealth + elementRelationship: associative + keys: + - resourceID +- name: io.k8s.api.core.v1.SELinuxOptions + map: + fields: + - name: level + type: + scalar: string + - name: role + type: + scalar: string + - name: type + type: + scalar: string + - name: user + type: + scalar: string +- name: io.k8s.api.core.v1.ScaleIOPersistentVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + default: xfs + - name: gateway + type: + scalar: string + default: "" + - name: protectionDomain + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.SecretReference + - name: sslEnabled + type: + scalar: boolean + - name: storageMode + type: + scalar: string + default: ThinProvisioned + - name: storagePool + type: + scalar: string + - name: system + type: + scalar: string + default: "" + - name: volumeName + type: + scalar: string +- name: io.k8s.api.core.v1.ScaleIOVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + default: xfs + - name: gateway + type: + scalar: string + default: "" + - name: protectionDomain + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: sslEnabled + type: + scalar: boolean + - name: storageMode + type: + scalar: string + default: ThinProvisioned + - name: storagePool + type: + scalar: string + - name: system + type: + scalar: string + default: "" + - name: volumeName + type: + scalar: string +- name: io.k8s.api.core.v1.ScopeSelector + map: + fields: + - name: matchExpressions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ScopedResourceSelectorRequirement + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.core.v1.ScopedResourceSelectorRequirement + map: + fields: + - name: operator + type: + scalar: string + default: "" + - name: scopeName + type: + scalar: string + default: "" + - name: values + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.SeccompProfile + map: + fields: + - name: localhostProfile + type: + scalar: string + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: localhostProfile + discriminatorValue: LocalhostProfile +- name: io.k8s.api.core.v1.Secret + map: + fields: + - name: apiVersion + type: + scalar: string + - name: data + type: + map: + elementType: + scalar: string + - name: immutable + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: stringData + type: + map: + elementType: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.core.v1.SecretEnvSource + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean +- name: io.k8s.api.core.v1.SecretKeySelector + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean + elementRelationship: atomic +- name: io.k8s.api.core.v1.SecretProjection + map: + fields: + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.KeyToPath + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: optional + type: + scalar: boolean +- name: io.k8s.api.core.v1.SecretReference + map: + fields: + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.SecretVolumeSource + map: + fields: + - name: defaultMode + type: + scalar: numeric + - name: items + type: + list: + elementType: + namedType: io.k8s.api.core.v1.KeyToPath + elementRelationship: atomic + - name: optional + type: + scalar: boolean + - name: secretName + type: + scalar: string +- name: io.k8s.api.core.v1.SecurityContext + map: + fields: + - name: allowPrivilegeEscalation + type: + scalar: boolean + - name: appArmorProfile + type: + namedType: io.k8s.api.core.v1.AppArmorProfile + - name: capabilities + type: + namedType: io.k8s.api.core.v1.Capabilities + - name: privileged + type: + scalar: boolean + - name: procMount + type: + scalar: string + - name: readOnlyRootFilesystem + type: + scalar: boolean + - name: runAsGroup + type: + scalar: numeric + - name: runAsNonRoot + type: + scalar: boolean + - name: runAsUser + type: + scalar: numeric + - name: seLinuxOptions + type: + namedType: io.k8s.api.core.v1.SELinuxOptions + - name: seccompProfile + type: + namedType: io.k8s.api.core.v1.SeccompProfile + - name: windowsOptions + type: + namedType: io.k8s.api.core.v1.WindowsSecurityContextOptions +- name: io.k8s.api.core.v1.Service + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.core.v1.ServiceSpec + default: {} + - name: status + type: + namedType: io.k8s.api.core.v1.ServiceStatus + default: {} +- name: io.k8s.api.core.v1.ServiceAccount + map: + fields: + - name: apiVersion + type: + scalar: string + - name: automountServiceAccountToken + type: + scalar: boolean + - name: imagePullSecrets + type: + list: + elementType: + namedType: io.k8s.api.core.v1.LocalObjectReference + elementRelationship: atomic + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: secrets + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ObjectReference + elementRelationship: associative + keys: + - name +- name: io.k8s.api.core.v1.ServiceAccountTokenProjection + map: + fields: + - name: audience + type: + scalar: string + - name: expirationSeconds + type: + scalar: numeric + - name: path + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.ServicePort + map: + fields: + - name: appProtocol + type: + scalar: string + - name: name + type: + scalar: string + - name: nodePort + type: + scalar: numeric + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + default: TCP + - name: targetPort + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.core.v1.ServiceSpec + map: + fields: + - name: allocateLoadBalancerNodePorts + type: + scalar: boolean + - name: clusterIP + type: + scalar: string + - name: clusterIPs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: externalIPs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: externalName + type: + scalar: string + - name: externalTrafficPolicy + type: + scalar: string + - name: healthCheckNodePort + type: + scalar: numeric + - name: internalTrafficPolicy + type: + scalar: string + - name: ipFamilies + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: ipFamilyPolicy + type: + scalar: string + - name: loadBalancerClass + type: + scalar: string + - name: loadBalancerIP + type: + scalar: string + - name: loadBalancerSourceRanges + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.core.v1.ServicePort + elementRelationship: associative + keys: + - port + - protocol + - name: publishNotReadyAddresses + type: + scalar: boolean + - name: selector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: sessionAffinity + type: + scalar: string + - name: sessionAffinityConfig + type: + namedType: io.k8s.api.core.v1.SessionAffinityConfig + - name: trafficDistribution + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.core.v1.ServiceStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: loadBalancer + type: + namedType: io.k8s.api.core.v1.LoadBalancerStatus + default: {} +- name: io.k8s.api.core.v1.SessionAffinityConfig + map: + fields: + - name: clientIP + type: + namedType: io.k8s.api.core.v1.ClientIPConfig +- name: io.k8s.api.core.v1.SleepAction + map: + fields: + - name: seconds + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.StorageOSPersistentVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: volumeName + type: + scalar: string + - name: volumeNamespace + type: + scalar: string +- name: io.k8s.api.core.v1.StorageOSVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: readOnly + type: + scalar: boolean + - name: secretRef + type: + namedType: io.k8s.api.core.v1.LocalObjectReference + - name: volumeName + type: + scalar: string + - name: volumeNamespace + type: + scalar: string +- name: io.k8s.api.core.v1.Sysctl + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: value + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.TCPSocketAction + map: + fields: + - name: host + type: + scalar: string + - name: port + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.core.v1.Taint + map: + fields: + - name: effect + type: + scalar: string + default: "" + - name: key + type: + scalar: string + default: "" + - name: timeAdded + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: value + type: + scalar: string +- name: io.k8s.api.core.v1.Toleration + map: + fields: + - name: effect + type: + scalar: string + - name: key + type: + scalar: string + - name: operator + type: + scalar: string + - name: tolerationSeconds + type: + scalar: numeric + - name: value + type: + scalar: string +- name: io.k8s.api.core.v1.TopologySelectorLabelRequirement + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: values + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.core.v1.TopologySelectorTerm + map: + fields: + - name: matchLabelExpressions + type: + list: + elementType: + namedType: io.k8s.api.core.v1.TopologySelectorLabelRequirement + elementRelationship: atomic + elementRelationship: atomic +- name: io.k8s.api.core.v1.TopologySpreadConstraint + map: + fields: + - name: labelSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: matchLabelKeys + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: maxSkew + type: + scalar: numeric + default: 0 + - name: minDomains + type: + scalar: numeric + - name: nodeAffinityPolicy + type: + scalar: string + - name: nodeTaintsPolicy + type: + scalar: string + - name: topologyKey + type: + scalar: string + default: "" + - name: whenUnsatisfiable + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.TypedLocalObjectReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.core.v1.TypedObjectReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string +- name: io.k8s.api.core.v1.Volume + map: + fields: + - name: awsElasticBlockStore + type: + namedType: io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource + - name: azureDisk + type: + namedType: io.k8s.api.core.v1.AzureDiskVolumeSource + - name: azureFile + type: + namedType: io.k8s.api.core.v1.AzureFileVolumeSource + - name: cephfs + type: + namedType: io.k8s.api.core.v1.CephFSVolumeSource + - name: cinder + type: + namedType: io.k8s.api.core.v1.CinderVolumeSource + - name: configMap + type: + namedType: io.k8s.api.core.v1.ConfigMapVolumeSource + - name: csi + type: + namedType: io.k8s.api.core.v1.CSIVolumeSource + - name: downwardAPI + type: + namedType: io.k8s.api.core.v1.DownwardAPIVolumeSource + - name: emptyDir + type: + namedType: io.k8s.api.core.v1.EmptyDirVolumeSource + - name: ephemeral + type: + namedType: io.k8s.api.core.v1.EphemeralVolumeSource + - name: fc + type: + namedType: io.k8s.api.core.v1.FCVolumeSource + - name: flexVolume + type: + namedType: io.k8s.api.core.v1.FlexVolumeSource + - name: flocker + type: + namedType: io.k8s.api.core.v1.FlockerVolumeSource + - name: gcePersistentDisk + type: + namedType: io.k8s.api.core.v1.GCEPersistentDiskVolumeSource + - name: gitRepo + type: + namedType: io.k8s.api.core.v1.GitRepoVolumeSource + - name: glusterfs + type: + namedType: io.k8s.api.core.v1.GlusterfsVolumeSource + - name: hostPath + type: + namedType: io.k8s.api.core.v1.HostPathVolumeSource + - name: image + type: + namedType: io.k8s.api.core.v1.ImageVolumeSource + - name: iscsi + type: + namedType: io.k8s.api.core.v1.ISCSIVolumeSource + - name: name + type: + scalar: string + default: "" + - name: nfs + type: + namedType: io.k8s.api.core.v1.NFSVolumeSource + - name: persistentVolumeClaim + type: + namedType: io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource + - name: photonPersistentDisk + type: + namedType: io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource + - name: portworxVolume + type: + namedType: io.k8s.api.core.v1.PortworxVolumeSource + - name: projected + type: + namedType: io.k8s.api.core.v1.ProjectedVolumeSource + - name: quobyte + type: + namedType: io.k8s.api.core.v1.QuobyteVolumeSource + - name: rbd + type: + namedType: io.k8s.api.core.v1.RBDVolumeSource + - name: scaleIO + type: + namedType: io.k8s.api.core.v1.ScaleIOVolumeSource + - name: secret + type: + namedType: io.k8s.api.core.v1.SecretVolumeSource + - name: storageos + type: + namedType: io.k8s.api.core.v1.StorageOSVolumeSource + - name: vsphereVolume + type: + namedType: io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource +- name: io.k8s.api.core.v1.VolumeDevice + map: + fields: + - name: devicePath + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.VolumeMount + map: + fields: + - name: mountPath + type: + scalar: string + default: "" + - name: mountPropagation + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean + - name: recursiveReadOnly + type: + scalar: string + - name: subPath + type: + scalar: string + - name: subPathExpr + type: + scalar: string +- name: io.k8s.api.core.v1.VolumeMountStatus + map: + fields: + - name: mountPath + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: readOnly + type: + scalar: boolean + - name: recursiveReadOnly + type: + scalar: string +- name: io.k8s.api.core.v1.VolumeNodeAffinity + map: + fields: + - name: required + type: + namedType: io.k8s.api.core.v1.NodeSelector +- name: io.k8s.api.core.v1.VolumeProjection + map: + fields: + - name: clusterTrustBundle + type: + namedType: io.k8s.api.core.v1.ClusterTrustBundleProjection + - name: configMap + type: + namedType: io.k8s.api.core.v1.ConfigMapProjection + - name: downwardAPI + type: + namedType: io.k8s.api.core.v1.DownwardAPIProjection + - name: secret + type: + namedType: io.k8s.api.core.v1.SecretProjection + - name: serviceAccountToken + type: + namedType: io.k8s.api.core.v1.ServiceAccountTokenProjection +- name: io.k8s.api.core.v1.VolumeResourceRequirements + map: + fields: + - name: limits + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: requests + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource + map: + fields: + - name: fsType + type: + scalar: string + - name: storagePolicyID + type: + scalar: string + - name: storagePolicyName + type: + scalar: string + - name: volumePath + type: + scalar: string + default: "" +- name: io.k8s.api.core.v1.WeightedPodAffinityTerm + map: + fields: + - name: podAffinityTerm + type: + namedType: io.k8s.api.core.v1.PodAffinityTerm + default: {} + - name: weight + type: + scalar: numeric + default: 0 +- name: io.k8s.api.core.v1.WindowsSecurityContextOptions + map: + fields: + - name: gmsaCredentialSpec + type: + scalar: string + - name: gmsaCredentialSpecName + type: + scalar: string + - name: hostProcess + type: + scalar: boolean + - name: runAsUserName + type: + scalar: string +- name: io.k8s.api.discovery.v1.Endpoint + map: + fields: + - name: addresses + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: conditions + type: + namedType: io.k8s.api.discovery.v1.EndpointConditions + default: {} + - name: deprecatedTopology + type: + map: + elementType: + scalar: string + - name: hints + type: + namedType: io.k8s.api.discovery.v1.EndpointHints + - name: hostname + type: + scalar: string + - name: nodeName + type: + scalar: string + - name: targetRef + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: zone + type: + scalar: string +- name: io.k8s.api.discovery.v1.EndpointConditions + map: + fields: + - name: ready + type: + scalar: boolean + - name: serving + type: + scalar: boolean + - name: terminating + type: + scalar: boolean +- name: io.k8s.api.discovery.v1.EndpointHints + map: + fields: + - name: forNodes + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1.ForNode + elementRelationship: atomic + - name: forZones + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1.ForZone + elementRelationship: atomic +- name: io.k8s.api.discovery.v1.EndpointPort + map: + fields: + - name: appProtocol + type: + scalar: string + - name: name + type: + scalar: string + - name: port + type: + scalar: numeric + - name: protocol + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.discovery.v1.EndpointSlice + map: + fields: + - name: addressType + type: + scalar: string + default: "" + - name: apiVersion + type: + scalar: string + - name: endpoints + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1.Endpoint + elementRelationship: atomic + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1.EndpointPort + elementRelationship: atomic +- name: io.k8s.api.discovery.v1.ForNode + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.discovery.v1.ForZone + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.discovery.v1beta1.Endpoint + map: + fields: + - name: addresses + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: conditions + type: + namedType: io.k8s.api.discovery.v1beta1.EndpointConditions + default: {} + - name: hints + type: + namedType: io.k8s.api.discovery.v1beta1.EndpointHints + - name: hostname + type: + scalar: string + - name: nodeName + type: + scalar: string + - name: targetRef + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: topology + type: + map: + elementType: + scalar: string +- name: io.k8s.api.discovery.v1beta1.EndpointConditions + map: + fields: + - name: ready + type: + scalar: boolean + - name: serving + type: + scalar: boolean + - name: terminating + type: + scalar: boolean +- name: io.k8s.api.discovery.v1beta1.EndpointHints + map: + fields: + - name: forNodes + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1beta1.ForNode + elementRelationship: atomic + - name: forZones + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1beta1.ForZone + elementRelationship: atomic +- name: io.k8s.api.discovery.v1beta1.EndpointPort + map: + fields: + - name: appProtocol + type: + scalar: string + - name: name + type: + scalar: string + - name: port + type: + scalar: numeric + - name: protocol + type: + scalar: string +- name: io.k8s.api.discovery.v1beta1.EndpointSlice + map: + fields: + - name: addressType + type: + scalar: string + default: "" + - name: apiVersion + type: + scalar: string + - name: endpoints + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1beta1.Endpoint + elementRelationship: atomic + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.discovery.v1beta1.EndpointPort + elementRelationship: atomic +- name: io.k8s.api.discovery.v1beta1.ForNode + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.discovery.v1beta1.ForZone + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.events.v1.Event + map: + fields: + - name: action + type: + scalar: string + - name: apiVersion + type: + scalar: string + - name: deprecatedCount + type: + scalar: numeric + - name: deprecatedFirstTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: deprecatedLastTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: deprecatedSource + type: + namedType: io.k8s.api.core.v1.EventSource + default: {} + - name: eventTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: note + type: + scalar: string + - name: reason + type: + scalar: string + - name: regarding + type: + namedType: io.k8s.api.core.v1.ObjectReference + default: {} + - name: related + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: reportingController + type: + scalar: string + - name: reportingInstance + type: + scalar: string + - name: series + type: + namedType: io.k8s.api.events.v1.EventSeries + - name: type + type: + scalar: string +- name: io.k8s.api.events.v1.EventSeries + map: + fields: + - name: count + type: + scalar: numeric + default: 0 + - name: lastObservedTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime +- name: io.k8s.api.events.v1beta1.Event + map: + fields: + - name: action + type: + scalar: string + - name: apiVersion + type: + scalar: string + - name: deprecatedCount + type: + scalar: numeric + - name: deprecatedFirstTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: deprecatedLastTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: deprecatedSource + type: + namedType: io.k8s.api.core.v1.EventSource + default: {} + - name: eventTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: note + type: + scalar: string + - name: reason + type: + scalar: string + - name: regarding + type: + namedType: io.k8s.api.core.v1.ObjectReference + default: {} + - name: related + type: + namedType: io.k8s.api.core.v1.ObjectReference + - name: reportingController + type: + scalar: string + - name: reportingInstance + type: + scalar: string + - name: series + type: + namedType: io.k8s.api.events.v1beta1.EventSeries + - name: type + type: + scalar: string +- name: io.k8s.api.events.v1beta1.EventSeries + map: + fields: + - name: count + type: + scalar: numeric + default: 0 + - name: lastObservedTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime +- name: io.k8s.api.extensions.v1beta1.DaemonSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.DaemonSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.extensions.v1beta1.DaemonSetStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.DaemonSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.DaemonSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} + - name: templateGeneration + type: + scalar: numeric + - name: updateStrategy + type: + namedType: io.k8s.api.extensions.v1beta1.DaemonSetUpdateStrategy + default: {} +- name: io.k8s.api.extensions.v1beta1.DaemonSetStatus + map: + fields: + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.DaemonSetCondition + elementRelationship: associative + keys: + - type + - name: currentNumberScheduled + type: + scalar: numeric + default: 0 + - name: desiredNumberScheduled + type: + scalar: numeric + default: 0 + - name: numberAvailable + type: + scalar: numeric + - name: numberMisscheduled + type: + scalar: numeric + default: 0 + - name: numberReady + type: + scalar: numeric + default: 0 + - name: numberUnavailable + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: updatedNumberScheduled + type: + scalar: numeric +- name: io.k8s.api.extensions.v1beta1.DaemonSetUpdateStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.extensions.v1beta1.RollingUpdateDaemonSet + - name: type + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.Deployment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.DeploymentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.extensions.v1beta1.DeploymentStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.DeploymentCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.DeploymentSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: paused + type: + scalar: boolean + - name: progressDeadlineSeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: revisionHistoryLimit + type: + scalar: numeric + - name: rollbackTo + type: + namedType: io.k8s.api.extensions.v1beta1.RollbackConfig + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: strategy + type: + namedType: io.k8s.api.extensions.v1beta1.DeploymentStrategy + default: {} + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.extensions.v1beta1.DeploymentStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: collisionCount + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.DeploymentCondition + elementRelationship: associative + keys: + - type + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: terminatingReplicas + type: + scalar: numeric + - name: unavailableReplicas + type: + scalar: numeric + - name: updatedReplicas + type: + scalar: numeric +- name: io.k8s.api.extensions.v1beta1.DeploymentStrategy + map: + fields: + - name: rollingUpdate + type: + namedType: io.k8s.api.extensions.v1beta1.RollingUpdateDeployment + - name: type + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.HTTPIngressPath + map: + fields: + - name: backend + type: + namedType: io.k8s.api.extensions.v1beta1.IngressBackend + default: {} + - name: path + type: + scalar: string + - name: pathType + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.HTTPIngressRuleValue + map: + fields: + - name: paths + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.HTTPIngressPath + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.IPBlock + map: + fields: + - name: cidr + type: + scalar: string + default: "" + - name: except + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.Ingress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.IngressSpec + default: {} + - name: status + type: + namedType: io.k8s.api.extensions.v1beta1.IngressStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.IngressBackend + map: + fields: + - name: resource + type: + namedType: io.k8s.api.core.v1.TypedLocalObjectReference + - name: serviceName + type: + scalar: string + - name: servicePort + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.extensions.v1beta1.IngressLoadBalancerIngress + map: + fields: + - name: hostname + type: + scalar: string + - name: ip + type: + scalar: string + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.IngressPortStatus + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.IngressLoadBalancerStatus + map: + fields: + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.IngressLoadBalancerIngress + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.IngressPortStatus + map: + fields: + - name: error + type: + scalar: string + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.IngressRule + map: + fields: + - name: host + type: + scalar: string + - name: http + type: + namedType: io.k8s.api.extensions.v1beta1.HTTPIngressRuleValue +- name: io.k8s.api.extensions.v1beta1.IngressSpec + map: + fields: + - name: backend + type: + namedType: io.k8s.api.extensions.v1beta1.IngressBackend + - name: ingressClassName + type: + scalar: string + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.IngressRule + elementRelationship: atomic + - name: tls + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.IngressTLS + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.IngressStatus + map: + fields: + - name: loadBalancer + type: + namedType: io.k8s.api.extensions.v1beta1.IngressLoadBalancerStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.IngressTLS + map: + fields: + - name: hosts + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: secretName + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.NetworkPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicySpec + default: {} +- name: io.k8s.api.extensions.v1beta1.NetworkPolicyEgressRule + map: + fields: + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyPort + elementRelationship: atomic + - name: to + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyPeer + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.NetworkPolicyIngressRule + map: + fields: + - name: from + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyPeer + elementRelationship: atomic + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyPort + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.NetworkPolicyPeer + map: + fields: + - name: ipBlock + type: + namedType: io.k8s.api.extensions.v1beta1.IPBlock + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: podSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.extensions.v1beta1.NetworkPolicyPort + map: + fields: + - name: endPort + type: + scalar: numeric + - name: port + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: protocol + type: + scalar: string +- name: io.k8s.api.extensions.v1beta1.NetworkPolicySpec + map: + fields: + - name: egress + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyEgressRule + elementRelationship: atomic + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.NetworkPolicyIngressRule + elementRelationship: atomic + - name: podSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + default: {} + - name: policyTypes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.extensions.v1beta1.ReplicaSet + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + default: {} +- name: io.k8s.api.extensions.v1beta1.ReplicaSetCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.extensions.v1beta1.ReplicaSetSpec + map: + fields: + - name: minReadySeconds + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: template + type: + namedType: io.k8s.api.core.v1.PodTemplateSpec + default: {} +- name: io.k8s.api.extensions.v1beta1.ReplicaSetStatus + map: + fields: + - name: availableReplicas + type: + scalar: numeric + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.extensions.v1beta1.ReplicaSetCondition + elementRelationship: associative + keys: + - type + - name: fullyLabeledReplicas + type: + scalar: numeric + - name: observedGeneration + type: + scalar: numeric + - name: readyReplicas + type: + scalar: numeric + - name: replicas + type: + scalar: numeric + default: 0 + - name: terminatingReplicas + type: + scalar: numeric +- name: io.k8s.api.extensions.v1beta1.RollbackConfig + map: + fields: + - name: revision + type: + scalar: numeric +- name: io.k8s.api.extensions.v1beta1.RollingUpdateDaemonSet + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.extensions.v1beta1.RollingUpdateDeployment + map: + fields: + - name: maxSurge + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.flowcontrol.v1.ExemptPriorityLevelConfiguration + map: + fields: + - name: lendablePercent + type: + scalar: numeric + - name: nominalConcurrencyShares + type: + scalar: numeric +- name: io.k8s.api.flowcontrol.v1.FlowDistinguisherMethod + map: + fields: + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1.FlowSchema + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1.FlowSchemaSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1.FlowSchemaStatus + default: {} +- name: io.k8s.api.flowcontrol.v1.FlowSchemaCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1.FlowSchemaSpec + map: + fields: + - name: distinguisherMethod + type: + namedType: io.k8s.api.flowcontrol.v1.FlowDistinguisherMethod + - name: matchingPrecedence + type: + scalar: numeric + default: 0 + - name: priorityLevelConfiguration + type: + namedType: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationReference + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.PolicyRulesWithSubjects + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1.FlowSchemaStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.FlowSchemaCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1.GroupSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1.LimitResponse + map: + fields: + - name: queuing + type: + namedType: io.k8s.api.flowcontrol.v1.QueuingConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: queuing + discriminatorValue: Queuing +- name: io.k8s.api.flowcontrol.v1.LimitedPriorityLevelConfiguration + map: + fields: + - name: borrowingLimitPercent + type: + scalar: numeric + - name: lendablePercent + type: + scalar: numeric + - name: limitResponse + type: + namedType: io.k8s.api.flowcontrol.v1.LimitResponse + default: {} + - name: nominalConcurrencyShares + type: + scalar: numeric +- name: io.k8s.api.flowcontrol.v1.NonResourcePolicyRule + map: + fields: + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1.PolicyRulesWithSubjects + map: + fields: + - name: nonResourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.NonResourcePolicyRule + elementRelationship: atomic + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.ResourcePolicyRule + elementRelationship: atomic + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.Subject + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1.PriorityLevelConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationStatus + default: {} +- name: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationSpec + map: + fields: + - name: exempt + type: + namedType: io.k8s.api.flowcontrol.v1.ExemptPriorityLevelConfiguration + - name: limited + type: + namedType: io.k8s.api.flowcontrol.v1.LimitedPriorityLevelConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: exempt + discriminatorValue: Exempt + - fieldName: limited + discriminatorValue: Limited +- name: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1.PriorityLevelConfigurationCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1.QueuingConfiguration + map: + fields: + - name: handSize + type: + scalar: numeric + default: 0 + - name: queueLengthLimit + type: + scalar: numeric + default: 0 + - name: queues + type: + scalar: numeric + default: 0 +- name: io.k8s.api.flowcontrol.v1.ResourcePolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: clusterScope + type: + scalar: boolean + - name: namespaces + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1.ServiceAccountSubject + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1.Subject + map: + fields: + - name: group + type: + namedType: io.k8s.api.flowcontrol.v1.GroupSubject + - name: kind + type: + scalar: string + default: "" + - name: serviceAccount + type: + namedType: io.k8s.api.flowcontrol.v1.ServiceAccountSubject + - name: user + type: + namedType: io.k8s.api.flowcontrol.v1.UserSubject + unions: + - discriminator: kind + fields: + - fieldName: group + discriminatorValue: Group + - fieldName: serviceAccount + discriminatorValue: ServiceAccount + - fieldName: user + discriminatorValue: User +- name: io.k8s.api.flowcontrol.v1.UserSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.ExemptPriorityLevelConfiguration + map: + fields: + - name: lendablePercent + type: + scalar: numeric + - name: nominalConcurrencyShares + type: + scalar: numeric +- name: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod + map: + fields: + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchema + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaSpec + map: + fields: + - name: distinguisherMethod + type: + namedType: io.k8s.api.flowcontrol.v1beta1.FlowDistinguisherMethod + - name: matchingPrecedence + type: + scalar: numeric + default: 0 + - name: priorityLevelConfiguration + type: + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta1.FlowSchemaStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.FlowSchemaCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta1.GroupSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.LimitResponse + map: + fields: + - name: queuing + type: + namedType: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: queuing + discriminatorValue: Queuing +- name: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration + map: + fields: + - name: assuredConcurrencyShares + type: + scalar: numeric + default: 0 + - name: borrowingLimitPercent + type: + scalar: numeric + - name: lendablePercent + type: + scalar: numeric + - name: limitResponse + type: + namedType: io.k8s.api.flowcontrol.v1beta1.LimitResponse + default: {} +- name: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule + map: + fields: + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta1.PolicyRulesWithSubjects + map: + fields: + - name: nonResourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.NonResourcePolicyRule + elementRelationship: atomic + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule + elementRelationship: atomic + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.Subject + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationSpec + map: + fields: + - name: exempt + type: + namedType: io.k8s.api.flowcontrol.v1beta1.ExemptPriorityLevelConfiguration + - name: limited + type: + namedType: io.k8s.api.flowcontrol.v1beta1.LimitedPriorityLevelConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: exempt + discriminatorValue: Exempt + - fieldName: limited + discriminatorValue: Limited +- name: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta1.PriorityLevelConfigurationCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta1.QueuingConfiguration + map: + fields: + - name: handSize + type: + scalar: numeric + default: 0 + - name: queueLengthLimit + type: + scalar: numeric + default: 0 + - name: queues + type: + scalar: numeric + default: 0 +- name: io.k8s.api.flowcontrol.v1beta1.ResourcePolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: clusterScope + type: + scalar: boolean + - name: namespaces + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta1.Subject + map: + fields: + - name: group + type: + namedType: io.k8s.api.flowcontrol.v1beta1.GroupSubject + - name: kind + type: + scalar: string + default: "" + - name: serviceAccount + type: + namedType: io.k8s.api.flowcontrol.v1beta1.ServiceAccountSubject + - name: user + type: + namedType: io.k8s.api.flowcontrol.v1beta1.UserSubject + unions: + - discriminator: kind + fields: + - fieldName: group + discriminatorValue: Group + - fieldName: serviceAccount + discriminatorValue: ServiceAccount + - fieldName: user + discriminatorValue: User +- name: io.k8s.api.flowcontrol.v1beta1.UserSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta2.ExemptPriorityLevelConfiguration + map: + fields: + - name: lendablePercent + type: + scalar: numeric + - name: nominalConcurrencyShares + type: + scalar: numeric +- name: io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod + map: + fields: + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchema + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaSpec + map: + fields: + - name: distinguisherMethod + type: + namedType: io.k8s.api.flowcontrol.v1beta2.FlowDistinguisherMethod + - name: matchingPrecedence + type: + scalar: numeric + default: 0 + - name: priorityLevelConfiguration + type: + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta2.FlowSchemaStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.FlowSchemaCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta2.GroupSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta2.LimitResponse + map: + fields: + - name: queuing + type: + namedType: io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: queuing + discriminatorValue: Queuing +- name: io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration + map: + fields: + - name: assuredConcurrencyShares + type: + scalar: numeric + default: 0 + - name: borrowingLimitPercent + type: + scalar: numeric + - name: lendablePercent + type: + scalar: numeric + - name: limitResponse + type: + namedType: io.k8s.api.flowcontrol.v1beta2.LimitResponse + default: {} +- name: io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule + map: + fields: + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta2.PolicyRulesWithSubjects + map: + fields: + - name: nonResourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.NonResourcePolicyRule + elementRelationship: atomic + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule + elementRelationship: atomic + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.Subject + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationSpec + map: + fields: + - name: exempt + type: + namedType: io.k8s.api.flowcontrol.v1beta2.ExemptPriorityLevelConfiguration + - name: limited + type: + namedType: io.k8s.api.flowcontrol.v1beta2.LimitedPriorityLevelConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: exempt + discriminatorValue: Exempt + - fieldName: limited + discriminatorValue: Limited +- name: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta2.PriorityLevelConfigurationCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta2.QueuingConfiguration + map: + fields: + - name: handSize + type: + scalar: numeric + default: 0 + - name: queueLengthLimit + type: + scalar: numeric + default: 0 + - name: queues + type: + scalar: numeric + default: 0 +- name: io.k8s.api.flowcontrol.v1beta2.ResourcePolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: clusterScope + type: + scalar: boolean + - name: namespaces + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta2.Subject + map: + fields: + - name: group + type: + namedType: io.k8s.api.flowcontrol.v1beta2.GroupSubject + - name: kind + type: + scalar: string + default: "" + - name: serviceAccount + type: + namedType: io.k8s.api.flowcontrol.v1beta2.ServiceAccountSubject + - name: user + type: + namedType: io.k8s.api.flowcontrol.v1beta2.UserSubject + unions: + - discriminator: kind + fields: + - fieldName: group + discriminatorValue: Group + - fieldName: serviceAccount + discriminatorValue: ServiceAccount + - fieldName: user + discriminatorValue: User +- name: io.k8s.api.flowcontrol.v1beta2.UserSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta3.ExemptPriorityLevelConfiguration + map: + fields: + - name: lendablePercent + type: + scalar: numeric + - name: nominalConcurrencyShares + type: + scalar: numeric +- name: io.k8s.api.flowcontrol.v1beta3.FlowDistinguisherMethod + map: + fields: + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta3.FlowSchema + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta3.FlowSchemaSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta3.FlowSchemaStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta3.FlowSchemaCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta3.FlowSchemaSpec + map: + fields: + - name: distinguisherMethod + type: + namedType: io.k8s.api.flowcontrol.v1beta3.FlowDistinguisherMethod + - name: matchingPrecedence + type: + scalar: numeric + default: 0 + - name: priorityLevelConfiguration + type: + namedType: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationReference + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.PolicyRulesWithSubjects + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta3.FlowSchemaStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.FlowSchemaCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta3.GroupSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta3.LimitResponse + map: + fields: + - name: queuing + type: + namedType: io.k8s.api.flowcontrol.v1beta3.QueuingConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: queuing + discriminatorValue: Queuing +- name: io.k8s.api.flowcontrol.v1beta3.LimitedPriorityLevelConfiguration + map: + fields: + - name: borrowingLimitPercent + type: + scalar: numeric + - name: lendablePercent + type: + scalar: numeric + - name: limitResponse + type: + namedType: io.k8s.api.flowcontrol.v1beta3.LimitResponse + default: {} + - name: nominalConcurrencyShares + type: + scalar: numeric + default: 0 +- name: io.k8s.api.flowcontrol.v1beta3.NonResourcePolicyRule + map: + fields: + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta3.PolicyRulesWithSubjects + map: + fields: + - name: nonResourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.NonResourcePolicyRule + elementRelationship: atomic + - name: resourceRules + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.ResourcePolicyRule + elementRelationship: atomic + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.Subject + elementRelationship: atomic +- name: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfiguration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationSpec + default: {} + - name: status + type: + namedType: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationStatus + default: {} +- name: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationCondition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + - name: type + type: + scalar: string +- name: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationReference + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationSpec + map: + fields: + - name: exempt + type: + namedType: io.k8s.api.flowcontrol.v1beta3.ExemptPriorityLevelConfiguration + - name: limited + type: + namedType: io.k8s.api.flowcontrol.v1beta3.LimitedPriorityLevelConfiguration + - name: type + type: + scalar: string + default: "" + unions: + - discriminator: type + fields: + - fieldName: exempt + discriminatorValue: Exempt + - fieldName: limited + discriminatorValue: Limited +- name: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.flowcontrol.v1beta3.PriorityLevelConfigurationCondition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.flowcontrol.v1beta3.QueuingConfiguration + map: + fields: + - name: handSize + type: + scalar: numeric + default: 0 + - name: queueLengthLimit + type: + scalar: numeric + default: 0 + - name: queues + type: + scalar: numeric + default: 0 +- name: io.k8s.api.flowcontrol.v1beta3.ResourcePolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: clusterScope + type: + scalar: boolean + - name: namespaces + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.flowcontrol.v1beta3.ServiceAccountSubject + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + default: "" +- name: io.k8s.api.flowcontrol.v1beta3.Subject + map: + fields: + - name: group + type: + namedType: io.k8s.api.flowcontrol.v1beta3.GroupSubject + - name: kind + type: + scalar: string + default: "" + - name: serviceAccount + type: + namedType: io.k8s.api.flowcontrol.v1beta3.ServiceAccountSubject + - name: user + type: + namedType: io.k8s.api.flowcontrol.v1beta3.UserSubject + unions: + - discriminator: kind + fields: + - fieldName: group + discriminatorValue: Group + - fieldName: serviceAccount + discriminatorValue: ServiceAccount + - fieldName: user + discriminatorValue: User +- name: io.k8s.api.flowcontrol.v1beta3.UserSubject + map: + fields: + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.imagepolicy.v1alpha1.ImageReview + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.imagepolicy.v1alpha1.ImageReviewSpec + default: {} + - name: status + type: + namedType: io.k8s.api.imagepolicy.v1alpha1.ImageReviewStatus + default: {} +- name: io.k8s.api.imagepolicy.v1alpha1.ImageReviewContainerSpec + map: + fields: + - name: image + type: + scalar: string +- name: io.k8s.api.imagepolicy.v1alpha1.ImageReviewSpec + map: + fields: + - name: annotations + type: + map: + elementType: + scalar: string + - name: containers + type: + list: + elementType: + namedType: io.k8s.api.imagepolicy.v1alpha1.ImageReviewContainerSpec + elementRelationship: atomic + - name: namespace + type: + scalar: string +- name: io.k8s.api.imagepolicy.v1alpha1.ImageReviewStatus + map: + fields: + - name: allowed + type: + scalar: boolean + default: false + - name: auditAnnotations + type: + map: + elementType: + scalar: string + - name: reason + type: + scalar: string +- name: io.k8s.api.networking.v1.HTTPIngressPath + map: + fields: + - name: backend + type: + namedType: io.k8s.api.networking.v1.IngressBackend + default: {} + - name: path + type: + scalar: string + - name: pathType + type: + scalar: string +- name: io.k8s.api.networking.v1.HTTPIngressRuleValue + map: + fields: + - name: paths + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.HTTPIngressPath + elementRelationship: atomic +- name: io.k8s.api.networking.v1.IPAddress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1.IPAddressSpec + default: {} +- name: io.k8s.api.networking.v1.IPAddressSpec + map: + fields: + - name: parentRef + type: + namedType: io.k8s.api.networking.v1.ParentReference +- name: io.k8s.api.networking.v1.IPBlock + map: + fields: + - name: cidr + type: + scalar: string + default: "" + - name: except + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.networking.v1.Ingress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1.IngressSpec + default: {} + - name: status + type: + namedType: io.k8s.api.networking.v1.IngressStatus + default: {} +- name: io.k8s.api.networking.v1.IngressBackend + map: + fields: + - name: resource + type: + namedType: io.k8s.api.core.v1.TypedLocalObjectReference + - name: service + type: + namedType: io.k8s.api.networking.v1.IngressServiceBackend +- name: io.k8s.api.networking.v1.IngressClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1.IngressClassSpec + default: {} +- name: io.k8s.api.networking.v1.IngressClassParametersReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + - name: scope + type: + scalar: string +- name: io.k8s.api.networking.v1.IngressClassSpec + map: + fields: + - name: controller + type: + scalar: string + - name: parameters + type: + namedType: io.k8s.api.networking.v1.IngressClassParametersReference +- name: io.k8s.api.networking.v1.IngressLoadBalancerIngress + map: + fields: + - name: hostname + type: + scalar: string + - name: ip + type: + scalar: string + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.IngressPortStatus + elementRelationship: atomic +- name: io.k8s.api.networking.v1.IngressLoadBalancerStatus + map: + fields: + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.IngressLoadBalancerIngress + elementRelationship: atomic +- name: io.k8s.api.networking.v1.IngressPortStatus + map: + fields: + - name: error + type: + scalar: string + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + default: "" +- name: io.k8s.api.networking.v1.IngressRule + map: + fields: + - name: host + type: + scalar: string + - name: http + type: + namedType: io.k8s.api.networking.v1.HTTPIngressRuleValue +- name: io.k8s.api.networking.v1.IngressServiceBackend + map: + fields: + - name: name + type: + scalar: string + default: "" + - name: port + type: + namedType: io.k8s.api.networking.v1.ServiceBackendPort + default: {} +- name: io.k8s.api.networking.v1.IngressSpec + map: + fields: + - name: defaultBackend + type: + namedType: io.k8s.api.networking.v1.IngressBackend + - name: ingressClassName + type: + scalar: string + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.IngressRule + elementRelationship: atomic + - name: tls + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.IngressTLS + elementRelationship: atomic +- name: io.k8s.api.networking.v1.IngressStatus + map: + fields: + - name: loadBalancer + type: + namedType: io.k8s.api.networking.v1.IngressLoadBalancerStatus + default: {} +- name: io.k8s.api.networking.v1.IngressTLS + map: + fields: + - name: hosts + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: secretName + type: + scalar: string +- name: io.k8s.api.networking.v1.NetworkPolicy + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1.NetworkPolicySpec + default: {} +- name: io.k8s.api.networking.v1.NetworkPolicyEgressRule + map: + fields: + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyPort + elementRelationship: atomic + - name: to + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyPeer + elementRelationship: atomic +- name: io.k8s.api.networking.v1.NetworkPolicyIngressRule + map: + fields: + - name: from + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyPeer + elementRelationship: atomic + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyPort + elementRelationship: atomic +- name: io.k8s.api.networking.v1.NetworkPolicyPeer + map: + fields: + - name: ipBlock + type: + namedType: io.k8s.api.networking.v1.IPBlock + - name: namespaceSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: podSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector +- name: io.k8s.api.networking.v1.NetworkPolicyPort + map: + fields: + - name: endPort + type: + scalar: numeric + - name: port + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: protocol + type: + scalar: string +- name: io.k8s.api.networking.v1.NetworkPolicySpec + map: + fields: + - name: egress + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyEgressRule + elementRelationship: atomic + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.networking.v1.NetworkPolicyIngressRule + elementRelationship: atomic + - name: podSelector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + default: {} + - name: policyTypes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.networking.v1.ParentReference + map: + fields: + - name: group + type: + scalar: string + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: resource + type: + scalar: string +- name: io.k8s.api.networking.v1.ServiceBackendPort + map: + fields: + - name: name + type: + scalar: string + - name: number + type: + scalar: numeric + elementRelationship: atomic +- name: io.k8s.api.networking.v1.ServiceCIDR + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1.ServiceCIDRSpec + default: {} + - name: status + type: + namedType: io.k8s.api.networking.v1.ServiceCIDRStatus + default: {} +- name: io.k8s.api.networking.v1.ServiceCIDRSpec + map: + fields: + - name: cidrs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.networking.v1.ServiceCIDRStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.networking.v1alpha1.IPAddress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1alpha1.IPAddressSpec + default: {} +- name: io.k8s.api.networking.v1alpha1.IPAddressSpec + map: + fields: + - name: parentRef + type: + namedType: io.k8s.api.networking.v1alpha1.ParentReference +- name: io.k8s.api.networking.v1alpha1.ParentReference + map: + fields: + - name: group + type: + scalar: string + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: resource + type: + scalar: string +- name: io.k8s.api.networking.v1alpha1.ServiceCIDR + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1alpha1.ServiceCIDRSpec + default: {} + - name: status + type: + namedType: io.k8s.api.networking.v1alpha1.ServiceCIDRStatus + default: {} +- name: io.k8s.api.networking.v1alpha1.ServiceCIDRSpec + map: + fields: + - name: cidrs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.networking.v1alpha1.ServiceCIDRStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.networking.v1beta1.HTTPIngressPath + map: + fields: + - name: backend + type: + namedType: io.k8s.api.networking.v1beta1.IngressBackend + default: {} + - name: path + type: + scalar: string + - name: pathType + type: + scalar: string +- name: io.k8s.api.networking.v1beta1.HTTPIngressRuleValue + map: + fields: + - name: paths + type: + list: + elementType: + namedType: io.k8s.api.networking.v1beta1.HTTPIngressPath + elementRelationship: atomic +- name: io.k8s.api.networking.v1beta1.IPAddress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1beta1.IPAddressSpec + default: {} +- name: io.k8s.api.networking.v1beta1.IPAddressSpec + map: + fields: + - name: parentRef + type: + namedType: io.k8s.api.networking.v1beta1.ParentReference +- name: io.k8s.api.networking.v1beta1.Ingress + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1beta1.IngressSpec + default: {} + - name: status + type: + namedType: io.k8s.api.networking.v1beta1.IngressStatus + default: {} +- name: io.k8s.api.networking.v1beta1.IngressBackend + map: + fields: + - name: resource + type: + namedType: io.k8s.api.core.v1.TypedLocalObjectReference + - name: serviceName + type: + scalar: string + - name: servicePort + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString +- name: io.k8s.api.networking.v1beta1.IngressClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1beta1.IngressClassSpec + default: {} +- name: io.k8s.api.networking.v1beta1.IngressClassParametersReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + - name: scope + type: + scalar: string +- name: io.k8s.api.networking.v1beta1.IngressClassSpec + map: + fields: + - name: controller + type: + scalar: string + - name: parameters + type: + namedType: io.k8s.api.networking.v1beta1.IngressClassParametersReference +- name: io.k8s.api.networking.v1beta1.IngressLoadBalancerIngress + map: + fields: + - name: hostname + type: + scalar: string + - name: ip + type: + scalar: string + - name: ports + type: + list: + elementType: + namedType: io.k8s.api.networking.v1beta1.IngressPortStatus + elementRelationship: atomic +- name: io.k8s.api.networking.v1beta1.IngressLoadBalancerStatus + map: + fields: + - name: ingress + type: + list: + elementType: + namedType: io.k8s.api.networking.v1beta1.IngressLoadBalancerIngress + elementRelationship: atomic +- name: io.k8s.api.networking.v1beta1.IngressPortStatus + map: + fields: + - name: error + type: + scalar: string + - name: port + type: + scalar: numeric + default: 0 + - name: protocol + type: + scalar: string + default: "" +- name: io.k8s.api.networking.v1beta1.IngressRule + map: + fields: + - name: host + type: + scalar: string + - name: http + type: + namedType: io.k8s.api.networking.v1beta1.HTTPIngressRuleValue +- name: io.k8s.api.networking.v1beta1.IngressSpec + map: + fields: + - name: backend + type: + namedType: io.k8s.api.networking.v1beta1.IngressBackend + - name: ingressClassName + type: + scalar: string + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.networking.v1beta1.IngressRule + elementRelationship: atomic + - name: tls + type: + list: + elementType: + namedType: io.k8s.api.networking.v1beta1.IngressTLS + elementRelationship: atomic +- name: io.k8s.api.networking.v1beta1.IngressStatus + map: + fields: + - name: loadBalancer + type: + namedType: io.k8s.api.networking.v1beta1.IngressLoadBalancerStatus + default: {} +- name: io.k8s.api.networking.v1beta1.IngressTLS + map: + fields: + - name: hosts + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: secretName + type: + scalar: string +- name: io.k8s.api.networking.v1beta1.ParentReference + map: + fields: + - name: group + type: + scalar: string + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: resource + type: + scalar: string +- name: io.k8s.api.networking.v1beta1.ServiceCIDR + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.networking.v1beta1.ServiceCIDRSpec + default: {} + - name: status + type: + namedType: io.k8s.api.networking.v1beta1.ServiceCIDRStatus + default: {} +- name: io.k8s.api.networking.v1beta1.ServiceCIDRSpec + map: + fields: + - name: cidrs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.networking.v1beta1.ServiceCIDRStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type +- name: io.k8s.api.node.v1.Overhead + map: + fields: + - name: podFixed + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.node.v1.RuntimeClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: handler + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: overhead + type: + namedType: io.k8s.api.node.v1.Overhead + - name: scheduling + type: + namedType: io.k8s.api.node.v1.Scheduling +- name: io.k8s.api.node.v1.Scheduling + map: + fields: + - name: nodeSelector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic +- name: io.k8s.api.node.v1alpha1.Overhead + map: + fields: + - name: podFixed + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.node.v1alpha1.RuntimeClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.node.v1alpha1.RuntimeClassSpec + default: {} +- name: io.k8s.api.node.v1alpha1.RuntimeClassSpec + map: + fields: + - name: overhead + type: + namedType: io.k8s.api.node.v1alpha1.Overhead + - name: runtimeHandler + type: + scalar: string + default: "" + - name: scheduling + type: + namedType: io.k8s.api.node.v1alpha1.Scheduling +- name: io.k8s.api.node.v1alpha1.Scheduling + map: + fields: + - name: nodeSelector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic +- name: io.k8s.api.node.v1beta1.Overhead + map: + fields: + - name: podFixed + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.node.v1beta1.RuntimeClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: handler + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: overhead + type: + namedType: io.k8s.api.node.v1beta1.Overhead + - name: scheduling + type: + namedType: io.k8s.api.node.v1beta1.Scheduling +- name: io.k8s.api.node.v1beta1.Scheduling + map: + fields: + - name: nodeSelector + type: + map: + elementType: + scalar: string + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.core.v1.Toleration + elementRelationship: atomic +- name: io.k8s.api.policy.v1.Eviction + map: + fields: + - name: apiVersion + type: + scalar: string + - name: deleteOptions + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} +- name: io.k8s.api.policy.v1.PodDisruptionBudget + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.policy.v1.PodDisruptionBudgetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.policy.v1.PodDisruptionBudgetStatus + default: {} +- name: io.k8s.api.policy.v1.PodDisruptionBudgetSpec + map: + fields: + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: minAvailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: unhealthyPodEvictionPolicy + type: + scalar: string +- name: io.k8s.api.policy.v1.PodDisruptionBudgetStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: currentHealthy + type: + scalar: numeric + default: 0 + - name: desiredHealthy + type: + scalar: numeric + default: 0 + - name: disruptedPods + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: disruptionsAllowed + type: + scalar: numeric + default: 0 + - name: expectedPods + type: + scalar: numeric + default: 0 + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.policy.v1beta1.Eviction + map: + fields: + - name: apiVersion + type: + scalar: string + - name: deleteOptions + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} +- name: io.k8s.api.policy.v1beta1.PodDisruptionBudget + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec + default: {} + - name: status + type: + namedType: io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus + default: {} +- name: io.k8s.api.policy.v1beta1.PodDisruptionBudgetSpec + map: + fields: + - name: maxUnavailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: minAvailable + type: + namedType: io.k8s.apimachinery.pkg.util.intstr.IntOrString + - name: selector + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: unhealthyPodEvictionPolicy + type: + scalar: string +- name: io.k8s.api.policy.v1beta1.PodDisruptionBudgetStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: currentHealthy + type: + scalar: numeric + default: 0 + - name: desiredHealthy + type: + scalar: numeric + default: 0 + - name: disruptedPods + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: disruptionsAllowed + type: + scalar: numeric + default: 0 + - name: expectedPods + type: + scalar: numeric + default: 0 + - name: observedGeneration + type: + scalar: numeric +- name: io.k8s.api.rbac.v1.AggregationRule + map: + fields: + - name: clusterRoleSelectors + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.ClusterRole + map: + fields: + - name: aggregationRule + type: + namedType: io.k8s.api.rbac.v1.AggregationRule + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.ClusterRoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.PolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.Role + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.RoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.RoleRef + map: + fields: + - name: apiGroup + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.api.rbac.v1.Subject + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.AggregationRule + map: + fields: + - name: clusterRoleSelectors + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.ClusterRole + map: + fields: + - name: aggregationRule + type: + namedType: io.k8s.api.rbac.v1alpha1.AggregationRule + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1alpha1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.ClusterRoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1alpha1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1alpha1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.PolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.Role + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1alpha1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.RoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1alpha1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1alpha1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1alpha1.RoleRef + map: + fields: + - name: apiGroup + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.rbac.v1alpha1.Subject + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string +- name: io.k8s.api.rbac.v1beta1.AggregationRule + map: + fields: + - name: clusterRoleSelectors + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.ClusterRole + map: + fields: + - name: aggregationRule + type: + namedType: io.k8s.api.rbac.v1beta1.AggregationRule + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1beta1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.ClusterRoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1beta1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1beta1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.PolicyRule + map: + fields: + - name: apiGroups + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: nonResourceURLs + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resourceNames + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: resources + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: verbs + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.Role + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: rules + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1beta1.PolicyRule + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.RoleBinding + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: roleRef + type: + namedType: io.k8s.api.rbac.v1beta1.RoleRef + default: {} + - name: subjects + type: + list: + elementType: + namedType: io.k8s.api.rbac.v1beta1.Subject + elementRelationship: atomic +- name: io.k8s.api.rbac.v1beta1.RoleRef + map: + fields: + - name: apiGroup + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.rbac.v1beta1.Subject + map: + fields: + - name: apiGroup + type: + scalar: string + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: namespace + type: + scalar: string +- name: io.k8s.api.resource.v1alpha3.AllocatedDeviceStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: data + type: + namedType: __untyped_atomic_ + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: networkData + type: + namedType: io.k8s.api.resource.v1alpha3.NetworkDeviceData + - name: pool + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.AllocationResult + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceAllocationResult + default: {} + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector +- name: io.k8s.api.resource.v1alpha3.BasicDevice + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: attributes + type: + map: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceAttribute + - name: capacity + type: + map: + elementType: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: consumesCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceCounterConsumption + elementRelationship: atomic + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: taints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceTaint + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.CELDeviceSelector + map: + fields: + - name: expression + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.Counter + map: + fields: + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.resource.v1alpha3.CounterSet + map: + fields: + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1alpha3.Counter + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.Device + map: + fields: + - name: basic + type: + namedType: io.k8s.api.resource.v1alpha3.BasicDevice + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.DeviceAllocationConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1alpha3.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: source + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.DeviceAllocationResult + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceAllocationConfiguration + elementRelationship: atomic + - name: results + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceRequestAllocationResult + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceAttribute + map: + fields: + - name: bool + type: + scalar: boolean + - name: int + type: + scalar: numeric + - name: string + type: + scalar: string + - name: version + type: + scalar: string +- name: io.k8s.api.resource.v1alpha3.DeviceClaim + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceClaimConfiguration + elementRelationship: atomic + - name: constraints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceConstraint + elementRelationship: atomic + - name: requests + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceRequest + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceClaimConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1alpha3.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceClassSpec + default: {} +- name: io.k8s.api.resource.v1alpha3.DeviceClassConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1alpha3.OpaqueDeviceConfiguration +- name: io.k8s.api.resource.v1alpha3.DeviceClassSpec + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceClassConfiguration + elementRelationship: atomic + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceSelector + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceConstraint + map: + fields: + - name: matchAttribute + type: + scalar: string + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceCounterConsumption + map: + fields: + - name: counterSet + type: + scalar: string + default: "" + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1alpha3.Counter +- name: io.k8s.api.resource.v1alpha3.DeviceRequest + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: firstAvailable + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceSubRequest + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceRequestAllocationResult + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: pool + type: + scalar: string + default: "" + - name: request + type: + scalar: string + default: "" + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceSelector + map: + fields: + - name: cel + type: + namedType: io.k8s.api.resource.v1alpha3.CELDeviceSelector +- name: io.k8s.api.resource.v1alpha3.DeviceSubRequest + map: + fields: + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceTaint + map: + fields: + - name: effect + type: + scalar: string + default: "" + - name: key + type: + scalar: string + default: "" + - name: timeAdded + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1alpha3.DeviceTaintRule + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceTaintRuleSpec + default: {} +- name: io.k8s.api.resource.v1alpha3.DeviceTaintRuleSpec + map: + fields: + - name: deviceSelector + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceTaintSelector + - name: taint + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceTaint + default: {} +- name: io.k8s.api.resource.v1alpha3.DeviceTaintSelector + map: + fields: + - name: device + type: + scalar: string + - name: deviceClassName + type: + scalar: string + - name: driver + type: + scalar: string + - name: pool + type: + scalar: string + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.DeviceSelector + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.DeviceToleration + map: + fields: + - name: effect + type: + scalar: string + - name: key + type: + scalar: string + - name: operator + type: + scalar: string + default: Equal + - name: tolerationSeconds + type: + scalar: numeric + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1alpha3.NetworkDeviceData + map: + fields: + - name: hardwareAddress + type: + scalar: string + - name: interfaceName + type: + scalar: string + - name: ips + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1alpha3.OpaqueDeviceConfiguration + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: parameters + type: + namedType: __untyped_atomic_ +- name: io.k8s.api.resource.v1alpha3.ResourceClaim + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.ResourceClaimSpec + default: {} + - name: status + type: + namedType: io.k8s.api.resource.v1alpha3.ResourceClaimStatus + default: {} +- name: io.k8s.api.resource.v1alpha3.ResourceClaimConsumerReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: resource + type: + scalar: string + default: "" + - name: uid + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1alpha3.ResourceClaimSpec + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1alpha3.DeviceClaim + default: {} +- name: io.k8s.api.resource.v1alpha3.ResourceClaimStatus + map: + fields: + - name: allocation + type: + namedType: io.k8s.api.resource.v1alpha3.AllocationResult + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.AllocatedDeviceStatus + elementRelationship: associative + keys: + - driver + - device + - pool + - name: reservedFor + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.ResourceClaimConsumerReference + elementRelationship: associative + keys: + - uid +- name: io.k8s.api.resource.v1alpha3.ResourceClaimTemplate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.ResourceClaimTemplateSpec + default: {} +- name: io.k8s.api.resource.v1alpha3.ResourceClaimTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.ResourceClaimSpec + default: {} +- name: io.k8s.api.resource.v1alpha3.ResourcePool + map: + fields: + - name: generation + type: + scalar: numeric + default: 0 + - name: name + type: + scalar: string + default: "" + - name: resourceSliceCount + type: + scalar: numeric + default: 0 +- name: io.k8s.api.resource.v1alpha3.ResourceSlice + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1alpha3.ResourceSliceSpec + default: {} +- name: io.k8s.api.resource.v1alpha3.ResourceSliceSpec + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.Device + elementRelationship: atomic + - name: driver + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: perDeviceNodeSelection + type: + scalar: boolean + - name: pool + type: + namedType: io.k8s.api.resource.v1alpha3.ResourcePool + default: {} + - name: sharedCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1alpha3.CounterSet + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.AllocatedDeviceStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: data + type: + namedType: __untyped_atomic_ + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: networkData + type: + namedType: io.k8s.api.resource.v1beta1.NetworkDeviceData + - name: pool + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.AllocationResult + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1beta1.DeviceAllocationResult + default: {} + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector +- name: io.k8s.api.resource.v1beta1.BasicDevice + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: attributes + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceAttribute + - name: capacity + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceCapacity + - name: consumesCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceCounterConsumption + elementRelationship: atomic + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: taints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceTaint + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.CELDeviceSelector + map: + fields: + - name: expression + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.Counter + map: + fields: + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.resource.v1beta1.CounterSet + map: + fields: + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta1.Counter + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.Device + map: + fields: + - name: basic + type: + namedType: io.k8s.api.resource.v1beta1.BasicDevice + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.DeviceAllocationConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta1.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: source + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.DeviceAllocationResult + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceAllocationConfiguration + elementRelationship: atomic + - name: results + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceRequestAllocationResult + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceAttribute + map: + fields: + - name: bool + type: + scalar: boolean + - name: int + type: + scalar: numeric + - name: string + type: + scalar: string + - name: version + type: + scalar: string +- name: io.k8s.api.resource.v1beta1.DeviceCapacity + map: + fields: + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.resource.v1beta1.DeviceClaim + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceClaimConfiguration + elementRelationship: atomic + - name: constraints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceConstraint + elementRelationship: atomic + - name: requests + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceRequest + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceClaimConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta1.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta1.DeviceClassSpec + default: {} +- name: io.k8s.api.resource.v1beta1.DeviceClassConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta1.OpaqueDeviceConfiguration +- name: io.k8s.api.resource.v1beta1.DeviceClassSpec + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceClassConfiguration + elementRelationship: atomic + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceSelector + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceConstraint + map: + fields: + - name: matchAttribute + type: + scalar: string + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceCounterConsumption + map: + fields: + - name: counterSet + type: + scalar: string + default: "" + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta1.Counter +- name: io.k8s.api.resource.v1beta1.DeviceRequest + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: firstAvailable + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceSubRequest + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceRequestAllocationResult + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: pool + type: + scalar: string + default: "" + - name: request + type: + scalar: string + default: "" + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceSelector + map: + fields: + - name: cel + type: + namedType: io.k8s.api.resource.v1beta1.CELDeviceSelector +- name: io.k8s.api.resource.v1beta1.DeviceSubRequest + map: + fields: + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.DeviceTaint + map: + fields: + - name: effect + type: + scalar: string + default: "" + - name: key + type: + scalar: string + default: "" + - name: timeAdded + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1beta1.DeviceToleration + map: + fields: + - name: effect + type: + scalar: string + - name: key + type: + scalar: string + - name: operator + type: + scalar: string + default: Equal + - name: tolerationSeconds + type: + scalar: numeric + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1beta1.NetworkDeviceData + map: + fields: + - name: hardwareAddress + type: + scalar: string + - name: interfaceName + type: + scalar: string + - name: ips + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta1.OpaqueDeviceConfiguration + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: parameters + type: + namedType: __untyped_atomic_ +- name: io.k8s.api.resource.v1beta1.ResourceClaim + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta1.ResourceClaimSpec + default: {} + - name: status + type: + namedType: io.k8s.api.resource.v1beta1.ResourceClaimStatus + default: {} +- name: io.k8s.api.resource.v1beta1.ResourceClaimConsumerReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: resource + type: + scalar: string + default: "" + - name: uid + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta1.ResourceClaimSpec + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1beta1.DeviceClaim + default: {} +- name: io.k8s.api.resource.v1beta1.ResourceClaimStatus + map: + fields: + - name: allocation + type: + namedType: io.k8s.api.resource.v1beta1.AllocationResult + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.AllocatedDeviceStatus + elementRelationship: associative + keys: + - driver + - device + - pool + - name: reservedFor + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.ResourceClaimConsumerReference + elementRelationship: associative + keys: + - uid +- name: io.k8s.api.resource.v1beta1.ResourceClaimTemplate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta1.ResourceClaimTemplateSpec + default: {} +- name: io.k8s.api.resource.v1beta1.ResourceClaimTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta1.ResourceClaimSpec + default: {} +- name: io.k8s.api.resource.v1beta1.ResourcePool + map: + fields: + - name: generation + type: + scalar: numeric + default: 0 + - name: name + type: + scalar: string + default: "" + - name: resourceSliceCount + type: + scalar: numeric + default: 0 +- name: io.k8s.api.resource.v1beta1.ResourceSlice + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta1.ResourceSliceSpec + default: {} +- name: io.k8s.api.resource.v1beta1.ResourceSliceSpec + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.Device + elementRelationship: atomic + - name: driver + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: perDeviceNodeSelection + type: + scalar: boolean + - name: pool + type: + namedType: io.k8s.api.resource.v1beta1.ResourcePool + default: {} + - name: sharedCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta1.CounterSet + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.AllocatedDeviceStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + elementRelationship: associative + keys: + - type + - name: data + type: + namedType: __untyped_atomic_ + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: networkData + type: + namedType: io.k8s.api.resource.v1beta2.NetworkDeviceData + - name: pool + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.AllocationResult + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1beta2.DeviceAllocationResult + default: {} + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector +- name: io.k8s.api.resource.v1beta2.CELDeviceSelector + map: + fields: + - name: expression + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.Counter + map: + fields: + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.resource.v1beta2.CounterSet + map: + fields: + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta2.Counter + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.Device + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: attributes + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceAttribute + - name: capacity + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceCapacity + - name: consumesCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceCounterConsumption + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: taints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceTaint + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceAllocationConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta2.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: source + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.DeviceAllocationResult + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceAllocationConfiguration + elementRelationship: atomic + - name: results + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceRequestAllocationResult + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceAttribute + map: + fields: + - name: bool + type: + scalar: boolean + - name: int + type: + scalar: numeric + - name: string + type: + scalar: string + - name: version + type: + scalar: string +- name: io.k8s.api.resource.v1beta2.DeviceCapacity + map: + fields: + - name: value + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity +- name: io.k8s.api.resource.v1beta2.DeviceClaim + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceClaimConfiguration + elementRelationship: atomic + - name: constraints + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceConstraint + elementRelationship: atomic + - name: requests + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceRequest + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceClaimConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta2.OpaqueDeviceConfiguration + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta2.DeviceClassSpec + default: {} +- name: io.k8s.api.resource.v1beta2.DeviceClassConfiguration + map: + fields: + - name: opaque + type: + namedType: io.k8s.api.resource.v1beta2.OpaqueDeviceConfiguration +- name: io.k8s.api.resource.v1beta2.DeviceClassSpec + map: + fields: + - name: config + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceClassConfiguration + elementRelationship: atomic + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceSelector + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceConstraint + map: + fields: + - name: matchAttribute + type: + scalar: string + - name: requests + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceCounterConsumption + map: + fields: + - name: counterSet + type: + scalar: string + default: "" + - name: counters + type: + map: + elementType: + namedType: io.k8s.api.resource.v1beta2.Counter +- name: io.k8s.api.resource.v1beta2.DeviceRequest + map: + fields: + - name: exactly + type: + namedType: io.k8s.api.resource.v1beta2.ExactDeviceRequest + - name: firstAvailable + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceSubRequest + elementRelationship: atomic + - name: name + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.DeviceRequestAllocationResult + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: device + type: + scalar: string + default: "" + - name: driver + type: + scalar: string + default: "" + - name: pool + type: + scalar: string + default: "" + - name: request + type: + scalar: string + default: "" + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceSelector + map: + fields: + - name: cel + type: + namedType: io.k8s.api.resource.v1beta2.CELDeviceSelector +- name: io.k8s.api.resource.v1beta2.DeviceSubRequest + map: + fields: + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.DeviceTaint + map: + fields: + - name: effect + type: + scalar: string + default: "" + - name: key + type: + scalar: string + default: "" + - name: timeAdded + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1beta2.DeviceToleration + map: + fields: + - name: effect + type: + scalar: string + - name: key + type: + scalar: string + - name: operator + type: + scalar: string + default: Equal + - name: tolerationSeconds + type: + scalar: numeric + - name: value + type: + scalar: string +- name: io.k8s.api.resource.v1beta2.ExactDeviceRequest + map: + fields: + - name: adminAccess + type: + scalar: boolean + - name: allocationMode + type: + scalar: string + - name: count + type: + scalar: numeric + - name: deviceClassName + type: + scalar: string + default: "" + - name: selectors + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceSelector + elementRelationship: atomic + - name: tolerations + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.DeviceToleration + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.NetworkDeviceData + map: + fields: + - name: hardwareAddress + type: + scalar: string + - name: interfaceName + type: + scalar: string + - name: ips + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.resource.v1beta2.OpaqueDeviceConfiguration + map: + fields: + - name: driver + type: + scalar: string + default: "" + - name: parameters + type: + namedType: __untyped_atomic_ +- name: io.k8s.api.resource.v1beta2.ResourceClaim + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta2.ResourceClaimSpec + default: {} + - name: status + type: + namedType: io.k8s.api.resource.v1beta2.ResourceClaimStatus + default: {} +- name: io.k8s.api.resource.v1beta2.ResourceClaimConsumerReference + map: + fields: + - name: apiGroup + type: + scalar: string + - name: name + type: + scalar: string + default: "" + - name: resource + type: + scalar: string + default: "" + - name: uid + type: + scalar: string + default: "" +- name: io.k8s.api.resource.v1beta2.ResourceClaimSpec + map: + fields: + - name: devices + type: + namedType: io.k8s.api.resource.v1beta2.DeviceClaim + default: {} +- name: io.k8s.api.resource.v1beta2.ResourceClaimStatus + map: + fields: + - name: allocation + type: + namedType: io.k8s.api.resource.v1beta2.AllocationResult + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.AllocatedDeviceStatus + elementRelationship: associative + keys: + - driver + - device + - pool + - name: reservedFor + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.ResourceClaimConsumerReference + elementRelationship: associative + keys: + - uid +- name: io.k8s.api.resource.v1beta2.ResourceClaimTemplate + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta2.ResourceClaimTemplateSpec + default: {} +- name: io.k8s.api.resource.v1beta2.ResourceClaimTemplateSpec + map: + fields: + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta2.ResourceClaimSpec + default: {} +- name: io.k8s.api.resource.v1beta2.ResourcePool + map: + fields: + - name: generation + type: + scalar: numeric + default: 0 + - name: name + type: + scalar: string + default: "" + - name: resourceSliceCount + type: + scalar: numeric + default: 0 +- name: io.k8s.api.resource.v1beta2.ResourceSlice + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.resource.v1beta2.ResourceSliceSpec + default: {} +- name: io.k8s.api.resource.v1beta2.ResourceSliceSpec + map: + fields: + - name: allNodes + type: + scalar: boolean + - name: devices + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.Device + elementRelationship: atomic + - name: driver + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + - name: nodeSelector + type: + namedType: io.k8s.api.core.v1.NodeSelector + - name: perDeviceNodeSelection + type: + scalar: boolean + - name: pool + type: + namedType: io.k8s.api.resource.v1beta2.ResourcePool + default: {} + - name: sharedCounters + type: + list: + elementType: + namedType: io.k8s.api.resource.v1beta2.CounterSet + elementRelationship: atomic +- name: io.k8s.api.scheduling.v1.PriorityClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: description + type: + scalar: string + - name: globalDefault + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: preemptionPolicy + type: + scalar: string + - name: value + type: + scalar: numeric + default: 0 +- name: io.k8s.api.scheduling.v1alpha1.PriorityClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: description + type: + scalar: string + - name: globalDefault + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: preemptionPolicy + type: + scalar: string + - name: value + type: + scalar: numeric + default: 0 +- name: io.k8s.api.scheduling.v1beta1.PriorityClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: description + type: + scalar: string + - name: globalDefault + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: preemptionPolicy + type: + scalar: string + - name: value + type: + scalar: numeric + default: 0 +- name: io.k8s.api.storage.v1.CSIDriver + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1.CSIDriverSpec + default: {} +- name: io.k8s.api.storage.v1.CSIDriverSpec + map: + fields: + - name: attachRequired + type: + scalar: boolean + - name: fsGroupPolicy + type: + scalar: string + - name: nodeAllocatableUpdatePeriodSeconds + type: + scalar: numeric + - name: podInfoOnMount + type: + scalar: boolean + - name: requiresRepublish + type: + scalar: boolean + - name: seLinuxMount + type: + scalar: boolean + - name: storageCapacity + type: + scalar: boolean + - name: tokenRequests + type: + list: + elementType: + namedType: io.k8s.api.storage.v1.TokenRequest + elementRelationship: atomic + - name: volumeLifecycleModes + type: + list: + elementType: + scalar: string + elementRelationship: associative +- name: io.k8s.api.storage.v1.CSINode + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1.CSINodeSpec + default: {} +- name: io.k8s.api.storage.v1.CSINodeDriver + map: + fields: + - name: allocatable + type: + namedType: io.k8s.api.storage.v1.VolumeNodeResources + - name: name + type: + scalar: string + default: "" + - name: nodeID + type: + scalar: string + default: "" + - name: topologyKeys + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.storage.v1.CSINodeSpec + map: + fields: + - name: drivers + type: + list: + elementType: + namedType: io.k8s.api.storage.v1.CSINodeDriver + elementRelationship: associative + keys: + - name +- name: io.k8s.api.storage.v1.CSIStorageCapacity + map: + fields: + - name: apiVersion + type: + scalar: string + - name: capacity + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: kind + type: + scalar: string + - name: maximumVolumeSize + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: nodeTopology + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: storageClassName + type: + scalar: string + default: "" +- name: io.k8s.api.storage.v1.StorageClass + map: + fields: + - name: allowVolumeExpansion + type: + scalar: boolean + - name: allowedTopologies + type: + list: + elementType: + namedType: io.k8s.api.core.v1.TopologySelectorTerm + elementRelationship: atomic + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: mountOptions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: parameters + type: + map: + elementType: + scalar: string + - name: provisioner + type: + scalar: string + default: "" + - name: reclaimPolicy + type: + scalar: string + - name: volumeBindingMode + type: + scalar: string +- name: io.k8s.api.storage.v1.TokenRequest + map: + fields: + - name: audience + type: + scalar: string + default: "" + - name: expirationSeconds + type: + scalar: numeric +- name: io.k8s.api.storage.v1.VolumeAttachment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1.VolumeAttachmentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.storage.v1.VolumeAttachmentStatus + default: {} +- name: io.k8s.api.storage.v1.VolumeAttachmentSource + map: + fields: + - name: inlineVolumeSpec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeSpec + - name: persistentVolumeName + type: + scalar: string +- name: io.k8s.api.storage.v1.VolumeAttachmentSpec + map: + fields: + - name: attacher + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + default: "" + - name: source + type: + namedType: io.k8s.api.storage.v1.VolumeAttachmentSource + default: {} +- name: io.k8s.api.storage.v1.VolumeAttachmentStatus + map: + fields: + - name: attachError + type: + namedType: io.k8s.api.storage.v1.VolumeError + - name: attached + type: + scalar: boolean + default: false + - name: attachmentMetadata + type: + map: + elementType: + scalar: string + - name: detachError + type: + namedType: io.k8s.api.storage.v1.VolumeError +- name: io.k8s.api.storage.v1.VolumeError + map: + fields: + - name: errorCode + type: + scalar: numeric + - name: message + type: + scalar: string + - name: time + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.storage.v1.VolumeNodeResources + map: + fields: + - name: count + type: + scalar: numeric +- name: io.k8s.api.storage.v1alpha1.CSIStorageCapacity + map: + fields: + - name: apiVersion + type: + scalar: string + - name: capacity + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: kind + type: + scalar: string + - name: maximumVolumeSize + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: nodeTopology + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: storageClassName + type: + scalar: string + default: "" +- name: io.k8s.api.storage.v1alpha1.VolumeAttachment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1alpha1.VolumeAttachmentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.storage.v1alpha1.VolumeAttachmentStatus + default: {} +- name: io.k8s.api.storage.v1alpha1.VolumeAttachmentSource + map: + fields: + - name: inlineVolumeSpec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeSpec + - name: persistentVolumeName + type: + scalar: string +- name: io.k8s.api.storage.v1alpha1.VolumeAttachmentSpec + map: + fields: + - name: attacher + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + default: "" + - name: source + type: + namedType: io.k8s.api.storage.v1alpha1.VolumeAttachmentSource + default: {} +- name: io.k8s.api.storage.v1alpha1.VolumeAttachmentStatus + map: + fields: + - name: attachError + type: + namedType: io.k8s.api.storage.v1alpha1.VolumeError + - name: attached + type: + scalar: boolean + default: false + - name: attachmentMetadata + type: + map: + elementType: + scalar: string + - name: detachError + type: + namedType: io.k8s.api.storage.v1alpha1.VolumeError +- name: io.k8s.api.storage.v1alpha1.VolumeAttributesClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: driverName + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: parameters + type: + map: + elementType: + scalar: string +- name: io.k8s.api.storage.v1alpha1.VolumeError + map: + fields: + - name: errorCode + type: + scalar: numeric + - name: message + type: + scalar: string + - name: time + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.storage.v1beta1.CSIDriver + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1beta1.CSIDriverSpec + default: {} +- name: io.k8s.api.storage.v1beta1.CSIDriverSpec + map: + fields: + - name: attachRequired + type: + scalar: boolean + - name: fsGroupPolicy + type: + scalar: string + - name: nodeAllocatableUpdatePeriodSeconds + type: + scalar: numeric + - name: podInfoOnMount + type: + scalar: boolean + - name: requiresRepublish + type: + scalar: boolean + - name: seLinuxMount + type: + scalar: boolean + - name: storageCapacity + type: + scalar: boolean + - name: tokenRequests + type: + list: + elementType: + namedType: io.k8s.api.storage.v1beta1.TokenRequest + elementRelationship: atomic + - name: volumeLifecycleModes + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.storage.v1beta1.CSINode + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1beta1.CSINodeSpec + default: {} +- name: io.k8s.api.storage.v1beta1.CSINodeDriver + map: + fields: + - name: allocatable + type: + namedType: io.k8s.api.storage.v1beta1.VolumeNodeResources + - name: name + type: + scalar: string + default: "" + - name: nodeID + type: + scalar: string + default: "" + - name: topologyKeys + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.api.storage.v1beta1.CSINodeSpec + map: + fields: + - name: drivers + type: + list: + elementType: + namedType: io.k8s.api.storage.v1beta1.CSINodeDriver + elementRelationship: associative + keys: + - name +- name: io.k8s.api.storage.v1beta1.CSIStorageCapacity + map: + fields: + - name: apiVersion + type: + scalar: string + - name: capacity + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: kind + type: + scalar: string + - name: maximumVolumeSize + type: + namedType: io.k8s.apimachinery.pkg.api.resource.Quantity + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: nodeTopology + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + - name: storageClassName + type: + scalar: string + default: "" +- name: io.k8s.api.storage.v1beta1.StorageClass + map: + fields: + - name: allowVolumeExpansion + type: + scalar: boolean + - name: allowedTopologies + type: + list: + elementType: + namedType: io.k8s.api.core.v1.TopologySelectorTerm + elementRelationship: atomic + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: mountOptions + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: parameters + type: + map: + elementType: + scalar: string + - name: provisioner + type: + scalar: string + default: "" + - name: reclaimPolicy + type: + scalar: string + - name: volumeBindingMode + type: + scalar: string +- name: io.k8s.api.storage.v1beta1.TokenRequest + map: + fields: + - name: audience + type: + scalar: string + default: "" + - name: expirationSeconds + type: + scalar: numeric +- name: io.k8s.api.storage.v1beta1.VolumeAttachment + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storage.v1beta1.VolumeAttachmentSpec + default: {} + - name: status + type: + namedType: io.k8s.api.storage.v1beta1.VolumeAttachmentStatus + default: {} +- name: io.k8s.api.storage.v1beta1.VolumeAttachmentSource + map: + fields: + - name: inlineVolumeSpec + type: + namedType: io.k8s.api.core.v1.PersistentVolumeSpec + - name: persistentVolumeName + type: + scalar: string +- name: io.k8s.api.storage.v1beta1.VolumeAttachmentSpec + map: + fields: + - name: attacher + type: + scalar: string + default: "" + - name: nodeName + type: + scalar: string + default: "" + - name: source + type: + namedType: io.k8s.api.storage.v1beta1.VolumeAttachmentSource + default: {} +- name: io.k8s.api.storage.v1beta1.VolumeAttachmentStatus + map: + fields: + - name: attachError + type: + namedType: io.k8s.api.storage.v1beta1.VolumeError + - name: attached + type: + scalar: boolean + default: false + - name: attachmentMetadata + type: + map: + elementType: + scalar: string + - name: detachError + type: + namedType: io.k8s.api.storage.v1beta1.VolumeError +- name: io.k8s.api.storage.v1beta1.VolumeAttributesClass + map: + fields: + - name: apiVersion + type: + scalar: string + - name: driverName + type: + scalar: string + default: "" + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: parameters + type: + map: + elementType: + scalar: string +- name: io.k8s.api.storage.v1beta1.VolumeError + map: + fields: + - name: errorCode + type: + scalar: numeric + - name: message + type: + scalar: string + - name: time + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.api.storage.v1beta1.VolumeNodeResources + map: + fields: + - name: count + type: + scalar: numeric +- name: io.k8s.api.storagemigration.v1alpha1.GroupVersionResource + map: + fields: + - name: group + type: + scalar: string + - name: resource + type: + scalar: string + - name: version + type: + scalar: string +- name: io.k8s.api.storagemigration.v1alpha1.MigrationCondition + map: + fields: + - name: lastUpdateTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + - name: reason + type: + scalar: string + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.api.storagemigration.v1alpha1.StorageVersionMigration + map: + fields: + - name: apiVersion + type: + scalar: string + - name: kind + type: + scalar: string + - name: metadata + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + default: {} + - name: spec + type: + namedType: io.k8s.api.storagemigration.v1alpha1.StorageVersionMigrationSpec + default: {} + - name: status + type: + namedType: io.k8s.api.storagemigration.v1alpha1.StorageVersionMigrationStatus + default: {} +- name: io.k8s.api.storagemigration.v1alpha1.StorageVersionMigrationSpec + map: + fields: + - name: continueToken + type: + scalar: string + - name: resource + type: + namedType: io.k8s.api.storagemigration.v1alpha1.GroupVersionResource + default: {} +- name: io.k8s.api.storagemigration.v1alpha1.StorageVersionMigrationStatus + map: + fields: + - name: conditions + type: + list: + elementType: + namedType: io.k8s.api.storagemigration.v1alpha1.MigrationCondition + elementRelationship: associative + keys: + - type + - name: resourceVersion + type: + scalar: string +- name: io.k8s.apimachinery.pkg.api.resource.Quantity + scalar: untyped +- name: io.k8s.apimachinery.pkg.apis.meta.v1.Condition + map: + fields: + - name: lastTransitionTime + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: message + type: + scalar: string + default: "" + - name: observedGeneration + type: + scalar: numeric + - name: reason + type: + scalar: string + default: "" + - name: status + type: + scalar: string + default: "" + - name: type + type: + scalar: string + default: "" +- name: io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions + map: + fields: + - name: apiVersion + type: + scalar: string + - name: dryRun + type: + list: + elementType: + scalar: string + elementRelationship: atomic + - name: gracePeriodSeconds + type: + scalar: numeric + - name: ignoreStoreReadErrorWithClusterBreakingPotential + type: + scalar: boolean + - name: kind + type: + scalar: string + - name: orphanDependents + type: + scalar: boolean + - name: preconditions + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions + - name: propagationPolicy + type: + scalar: string +- name: io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1 + map: + elementType: + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_deduced_ + elementRelationship: separable +- name: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector + map: + fields: + - name: matchExpressions + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement + elementRelationship: atomic + - name: matchLabels + type: + map: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement + map: + fields: + - name: key + type: + scalar: string + default: "" + - name: operator + type: + scalar: string + default: "" + - name: values + type: + list: + elementType: + scalar: string + elementRelationship: atomic +- name: io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry + map: + fields: + - name: apiVersion + type: + scalar: string + - name: fieldsType + type: + scalar: string + - name: fieldsV1 + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1 + - name: manager + type: + scalar: string + - name: operation + type: + scalar: string + - name: subresource + type: + scalar: string + - name: time + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time +- name: io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime + scalar: untyped +- name: io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta + map: + fields: + - name: annotations + type: + map: + elementType: + scalar: string + - name: creationTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: deletionGracePeriodSeconds + type: + scalar: numeric + - name: deletionTimestamp + type: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.Time + - name: finalizers + type: + list: + elementType: + scalar: string + elementRelationship: associative + - name: generateName + type: + scalar: string + - name: generation + type: + scalar: numeric + - name: labels + type: + map: + elementType: + scalar: string + - name: managedFields + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry + elementRelationship: atomic + - name: name + type: + scalar: string + - name: namespace + type: + scalar: string + - name: ownerReferences + type: + list: + elementType: + namedType: io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference + elementRelationship: associative + keys: + - uid + - name: resourceVersion + type: + scalar: string + - name: selfLink + type: + scalar: string + - name: uid + type: + scalar: string +- name: io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference + map: + fields: + - name: apiVersion + type: + scalar: string + default: "" + - name: blockOwnerDeletion + type: + scalar: boolean + - name: controller + type: + scalar: boolean + - name: kind + type: + scalar: string + default: "" + - name: name + type: + scalar: string + default: "" + - name: uid + type: + scalar: string + default: "" + elementRelationship: atomic +- name: io.k8s.apimachinery.pkg.apis.meta.v1.Preconditions + map: + fields: + - name: resourceVersion + type: + scalar: string + - name: uid + type: + scalar: string +- name: io.k8s.apimachinery.pkg.apis.meta.v1.Time + scalar: untyped +- name: io.k8s.apimachinery.pkg.runtime.RawExtension + map: + elementType: + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_deduced_ + elementRelationship: separable +- name: io.k8s.apimachinery.pkg.util.intstr.IntOrString + scalar: untyped +- name: __untyped_atomic_ + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic +- name: __untyped_deduced_ + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_deduced_ + elementRelationship: separable +`) diff --git a/gitops-engine/pkg/utils/kube/scheme/scheme.go b/gitops-engine/pkg/utils/kube/scheme/scheme.go new file mode 100644 index 0000000000000..db105c814447f --- /dev/null +++ b/gitops-engine/pkg/utils/kube/scheme/scheme.go @@ -0,0 +1,29 @@ +package scheme + +import ( + "k8s.io/kubernetes/pkg/api/legacyscheme" + + _ "k8s.io/kubernetes/pkg/apis/admission/install" + _ "k8s.io/kubernetes/pkg/apis/admissionregistration/install" + _ "k8s.io/kubernetes/pkg/apis/apps/install" + _ "k8s.io/kubernetes/pkg/apis/authentication/install" + _ "k8s.io/kubernetes/pkg/apis/authorization/install" + _ "k8s.io/kubernetes/pkg/apis/autoscaling/install" + _ "k8s.io/kubernetes/pkg/apis/batch/install" + _ "k8s.io/kubernetes/pkg/apis/certificates/install" + _ "k8s.io/kubernetes/pkg/apis/coordination/install" + _ "k8s.io/kubernetes/pkg/apis/core/install" + _ "k8s.io/kubernetes/pkg/apis/discovery/install" + _ "k8s.io/kubernetes/pkg/apis/events/install" + _ "k8s.io/kubernetes/pkg/apis/extensions/install" + _ "k8s.io/kubernetes/pkg/apis/flowcontrol/install" + _ "k8s.io/kubernetes/pkg/apis/imagepolicy/install" + _ "k8s.io/kubernetes/pkg/apis/networking/install" + _ "k8s.io/kubernetes/pkg/apis/node/install" + _ "k8s.io/kubernetes/pkg/apis/policy/install" + _ "k8s.io/kubernetes/pkg/apis/rbac/install" + _ "k8s.io/kubernetes/pkg/apis/scheduling/install" + _ "k8s.io/kubernetes/pkg/apis/storage/install" +) + +var Scheme = legacyscheme.Scheme diff --git a/gitops-engine/pkg/utils/kube/scheme/typed.go b/gitops-engine/pkg/utils/kube/scheme/typed.go new file mode 100644 index 0000000000000..c660666e13b91 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/scheme/typed.go @@ -0,0 +1,77 @@ +package scheme + +import ( + "reflect" + "sync" + + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/util/managedfields" + "sigs.k8s.io/structured-merge-diff/v6/typed" +) + +// ResolveParseableType will build and return a ParseableType object +// based on the given gvk and GvkParser. If the given gvkParser is nil +// it will return a DeducedParseableType which is not suitable for +// calculating diffs. Will use the statically defined schema for k8s +// built in types. Will rely on the given gvk parser for CRD schemas. +func ResolveParseableType(gvk schema.GroupVersionKind, parser *managedfields.GvkParser) *typed.ParseableType { + if parser == nil { + return &typed.DeducedParseableType + } + pt := resolveFromStaticParser(gvk, parser) + if pt == nil { + return parser.Type(gvk) + } + return pt +} + +func resolveFromStaticParser(gvk schema.GroupVersionKind, parser *managedfields.GvkParser) *typed.ParseableType { + gvkNameMap := getGvkMap(parser) + name := gvkNameMap[gvk] + if name == "" { + return nil + } + + p := StaticParser() + if p == nil { + return nil + } + pt := p.Type(name) + if pt.IsValid() { + return &pt + } + return nil +} + +var ( + gvkMap map[schema.GroupVersionKind]string + extractOnce sync.Once +) + +func getGvkMap(parser *managedfields.GvkParser) map[schema.GroupVersionKind]string { + extractOnce.Do(func() { + gvkMap = extractGvkMap(parser) + }) + return gvkMap +} + +func extractGvkMap(parser *managedfields.GvkParser) map[schema.GroupVersionKind]string { + results := make(map[schema.GroupVersionKind]string) + + value := reflect.ValueOf(parser) + gvkValue := reflect.Indirect(value).FieldByName("gvks") + iter := gvkValue.MapRange() + for iter.Next() { + group := iter.Key().FieldByName("Group").String() + version := iter.Key().FieldByName("Version").String() + kind := iter.Key().FieldByName("Kind").String() + gvk := schema.GroupVersionKind{ + Group: group, + Version: version, + Kind: kind, + } + name := iter.Value().String() + results[gvk] = name + } + return results +} diff --git a/gitops-engine/pkg/utils/kube/testdata/appsdeployment.yaml b/gitops-engine/pkg/utils/kube/testdata/appsdeployment.yaml new file mode 100644 index 0000000000000..7e44d8ea8eeef --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/appsdeployment.yaml @@ -0,0 +1,13 @@ +apiVersion: apps/v1beta2 +kind: Deployment +metadata: + name: nginx-deployment +spec: + template: + metadata: + labels: + name: nginx + spec: + containers: + - name: nginx + image: nginx diff --git a/gitops-engine/pkg/utils/kube/testdata/cr.yaml b/gitops-engine/pkg/utils/kube/testdata/cr.yaml new file mode 100644 index 0000000000000..122bd4cdcf602 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/cr.yaml @@ -0,0 +1,13 @@ +apiVersion: argoproj.io/v1alpha1 +kind: Application +metadata: + name: custom-resource + namespace: default +spec: + destination: + namespace: default + server: https://kubernetes.default.svc + project: default + source: + path: guestbook + repoURL: https://github.com/argoproj/argocd-example-apps.git \ No newline at end of file diff --git a/gitops-engine/pkg/utils/kube/testdata/extensionsdeployment.yaml b/gitops-engine/pkg/utils/kube/testdata/extensionsdeployment.yaml new file mode 100644 index 0000000000000..d295072d4b807 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/extensionsdeployment.yaml @@ -0,0 +1,13 @@ +apiVersion: extensions/v1beta1 +kind: Deployment +metadata: + name: nginx-deployment +spec: + template: + metadata: + labels: + name: nginx + spec: + containers: + - name: nginx + image: nginx diff --git a/gitops-engine/pkg/utils/kube/testdata/nginx.yaml b/gitops-engine/pkg/utils/kube/testdata/nginx.yaml new file mode 100644 index 0000000000000..8cb365d69adde --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/nginx.yaml @@ -0,0 +1,66 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + annotations: + deployment.kubernetes.io/revision: "1" + creationTimestamp: 2018-07-05T09:30:00Z + generation: 1 + labels: + app: nginx + name: nginx-deployment + namespace: default + resourceVersion: "5140192" + selfLink: /apis/apps/v1/namespaces/default/deployments/nginx-deployment + uid: fd131d5c-8035-11e8-a525-42010a8a006c +spec: + progressDeadlineSeconds: 600 + replicas: 1 + revisionHistoryLimit: 2 + selector: + matchLabels: + app: nginx + strategy: + rollingUpdate: + maxSurge: 25% + maxUnavailable: 25% + type: RollingUpdate + template: + metadata: + creationTimestamp: null + labels: + app: nginx + spec: + containers: + - image: nginx:1.7.9 + imagePullPolicy: IfNotPresent + name: nginx + ports: + - containerPort: 80 + protocol: TCP + resources: {} + terminationMessagePath: /dev/termination-log + terminationMessagePolicy: File + dnsPolicy: ClusterFirst + restartPolicy: Always + schedulerName: default-scheduler + securityContext: {} + terminationGracePeriodSeconds: 30 +status: + availableReplicas: 1 + conditions: + - lastTransitionTime: 2018-07-05T09:30:00Z + lastUpdateTime: 2018-07-05T09:30:09Z + message: ReplicaSet "nginx-deployment-648fdd98d4" has successfully progressed. + reason: NewReplicaSetAvailable + status: "True" + type: Progressing + - lastTransitionTime: 2018-07-06T15:23:51Z + lastUpdateTime: 2018-07-06T15:23:51Z + message: Deployment has minimum availability. + reason: MinimumReplicasAvailable + status: "True" + type: Available + observedGeneration: 1 + readyReplicas: 1 + replicas: 1 + updatedReplicas: 1 diff --git a/gitops-engine/pkg/utils/kube/testdata/openapi_v2.json b/gitops-engine/pkg/utils/kube/testdata/openapi_v2.json new file mode 100644 index 0000000000000..77b824607217f --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/openapi_v2.json @@ -0,0 +1,516 @@ +{ + "definitions": { + "additional_properties": [ + { + "name": "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource", + "value": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": { + "value": [ + "object" + ] + }, + "properties": { + "additional_properties": [ + { + "name": "categories", + "value": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + }, + "vendor_extension": [ + { + "name": "x-kubernetes-list-type", + "value": { + "yaml": "atomic\n" + } + } + ] + } + }, + { + "name": "group", + "value": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "kind", + "value": { + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "name", + "value": { + "description": "name is the plural name of the resource.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "namespaced", + "value": { + "description": "namespaced indicates if a resource is namespaced or not.", + "type": { + "value": [ + "boolean" + ] + } + } + }, + { + "name": "shortNames", + "value": { + "description": "shortNames is a list of suggested short names of the resource.", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + }, + "vendor_extension": [ + { + "name": "x-kubernetes-list-type", + "value": { + "yaml": "atomic\n" + } + } + ] + } + }, + { + "name": "singularName", + "value": { + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "storageVersionHash", + "value": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "verbs", + "value": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + } + } + }, + { + "name": "version", + "value": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": { + "value": [ + "string" + ] + } + } + } + ] + } + } + }, + { + "name": "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList", + "value": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "required": [ + "groupVersion", + "resources" + ], + "type": { + "value": [ + "object" + ] + }, + "properties": { + "additional_properties": [ + { + "name": "apiVersion", + "value": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "groupVersion", + "value": { + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "kind", + "value": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "resources", + "value": { + "description": "resources contains the name of the resources and if they are namespaced.", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "_ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource" + } + ] + }, + "vendor_extension": [ + { + "name": "x-kubernetes-list-type", + "value": { + "yaml": "atomic\n" + } + } + ] + } + } + ] + }, + "vendor_extension": [ + { + "name": "x-kubernetes-group-version-kind", + "value": { + "yaml": "- group: \"\"\n kind: APIResourceList\n version: v1\n" + } + } + ] + } + }, + { + "name": "io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList_v2", + "value": { + "description": "APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.", + "required": [ + "groupVersion", + "resources" + ], + "type": { + "value": [ + "object" + ] + }, + "properties": { + "additional_properties": [ + { + "name": "apiVersion", + "value": { + "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "groupVersion", + "value": { + "description": "groupVersion is the group and version this APIResourceList is for.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "kind", + "value": { + "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "resources", + "value": { + "description": "resources contains the name of the resources and if they are namespaced.", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "_ref": "#/definitions/io.k8s.apimachinery.pkg.apis.meta.v1.APIResource_v2" + } + ] + } + } + } + ] + }, + "vendor_extension": [ + { + "name": "x-kubernetes-group-version-kind", + "value": { + "yaml": "- group: \"\"\n kind: APIResourceList\n version: v1\n" + } + } + ] + } + }, + { + "name": "io.k8s.apimachinery.pkg.apis.meta.v1.APIResource_v2", + "value": { + "description": "APIResource specifies the name of a resource and whether it is namespaced.", + "required": [ + "name", + "singularName", + "namespaced", + "kind", + "verbs" + ], + "type": { + "value": [ + "object" + ] + }, + "properties": { + "additional_properties": [ + { + "name": "categories", + "value": { + "description": "categories is a list of the grouped resources this resource belongs to (e.g. 'all')", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + } + } + }, + { + "name": "group", + "value": { + "description": "group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\".", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "kind", + "value": { + "description": "kind is the kind for the resource (e.g. 'Foo' is the kind for a resource 'foo')", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "name", + "value": { + "description": "name is the plural name of the resource.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "namespaced", + "value": { + "description": "namespaced indicates if a resource is namespaced or not.", + "type": { + "value": [ + "boolean" + ] + } + } + }, + { + "name": "shortNames", + "value": { + "description": "shortNames is a list of suggested short names of the resource.", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + } + } + }, + { + "name": "singularName", + "value": { + "description": "singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "storageVersionHash", + "value": { + "description": "The hash value of the storage version, the version this resource is converted to when written to the data store. Value must be treated as opaque by clients. Only equality comparison on the value is valid. This is an alpha feature and may change or be removed in the future. The field is populated by the apiserver only if the StorageVersionHash feature gate is enabled. This field will remain optional even if it graduates.", + "type": { + "value": [ + "string" + ] + } + } + }, + { + "name": "verbs", + "value": { + "description": "verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy)", + "type": { + "value": [ + "array" + ] + }, + "items": { + "schema": [ + { + "type": { + "value": [ + "string" + ] + } + } + ] + } + } + }, + { + "name": "version", + "value": { + "description": "version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource's group)\".", + "type": { + "value": [ + "string" + ] + } + } + } + ] + } + } + } + ] + } +} diff --git a/gitops-engine/pkg/utils/kube/testdata/v1HPA.yaml b/gitops-engine/pkg/utils/kube/testdata/v1HPA.yaml new file mode 100644 index 0000000000000..f3f1ef5d4f912 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/v1HPA.yaml @@ -0,0 +1,12 @@ +apiVersion: autoscaling/v1 +kind: HorizontalPodAutoscaler +metadata: + name: php-apache +spec: + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: php-apache + minReplicas: 1 + maxReplicas: 10 + targetCPUUtilizationPercentage: 50 diff --git a/gitops-engine/pkg/utils/kube/testdata/v2beta1HPA.yaml b/gitops-engine/pkg/utils/kube/testdata/v2beta1HPA.yaml new file mode 100644 index 0000000000000..88a5dc7001adc --- /dev/null +++ b/gitops-engine/pkg/utils/kube/testdata/v2beta1HPA.yaml @@ -0,0 +1,16 @@ +apiVersion: autoscaling/v2beta1 +kind: HorizontalPodAutoscaler +metadata: + name: php-apache +spec: + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: php-apache + minReplicas: 1 + maxReplicas: 10 + metrics: + - type: Resource + resource: + name: cpu + targetAverageUtilization: 50 diff --git a/gitops-engine/pkg/utils/kube/uniqueprotomodels.go b/gitops-engine/pkg/utils/kube/uniqueprotomodels.go new file mode 100644 index 0000000000000..ba8b2a3ea3888 --- /dev/null +++ b/gitops-engine/pkg/utils/kube/uniqueprotomodels.go @@ -0,0 +1,191 @@ +package kube + +import ( + "fmt" + "sort" + + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/kube-openapi/pkg/util/proto" +) + +/** +The upstream Kubernetes NewGVKParser method causes problems for Argo CD. +https://github.com/kubernetes/apimachinery/blob/eb26334eeb0f769be8f0c5665ff34713cfdec83e/pkg/util/managedfields/gvkparser.go#L73 + +The function fails in instances where it is probably more desirable for Argo CD to simply ignore the error and move on. +But since the upstream implementation doesn't offer the option to ignore the error, we have to mutate the input to the +function to completely avoid the case that can produce the error. + +When encountering the error from NewGVKParser, we used to just set the internal GVKParser instance to nil, log the +error as info, and move on. + +But Argo CD increasingly relies on the GVKParser to produce reliable diffs, especially with server-side diffing. And +we're better off with an incorrectly-initialized GVKParser than no GVKParser at all. + +To understand why NewGVKParser fails, we need to understand how Kubernetes constructs its OpenAPI models. + +Kubernetes contains a built-in OpenAPI document containing the `definitions` for every built-in Kubernetes API. This +document includes shared structs like APIResourceList. Some of these definitions include an +x-kubernetes-group-version-kind extension. + +Aggregated APIs produce their own OpenAPI documents, which are merged with the built-in OpenAPI document. The aggregated +API documents generally include all the definitions of all the structs which are used anywhere by the API. This often +includes some of the same structs as the built-in OpenAPI document. + +So when Kubernetes constructs the complete OpenAPI document (the one served at /openapi/v2), it merges the built-in +OpenAPI document with the aggregated API OpenAPI documents. + +When the aggregator encounters two different definitions for the same struct (as determined by a deep compare) with the +same GVK (as determined by the value in the x-kubernetes-group-version-kind extension), it appends a `_vX` suffix to the +definition name in the OpenAPI document (where X is the count of the number of times the aggregator has seen the same +definition). Basically, it's communicating "different APIs have different opinions about the structure of structs with +this GVK, so I'm going to give them different names and let you sort it out." +https://github.com/kubernetes/kube-openapi/blob/b456828f718bab62dc3013d192665eb3d17f8fe9/pkg/aggregator/aggregator.go#L238-L279 + +This behavior is fine from the perspective of a typical Kubernetes API user. They download the OpenAPI document, they +see that there are two different "opinions" about the structure of a struct, and they can choose which one they want to +rely on. + +But Argo CD has to be generic. We need to take the provided OpenAPI document and use it to construct a GVKParser. And +the GVKParser (reasonably) rejects the OpenAPI document if it contains two definitions for the same struct. + +So we have to do some work to make the OpenAPI document palatable to the GVKParser. We have to remove the duplicate +definitions. Specifically, we take the first one and log a warning for each subsequent definition with the same GVK. + +In practice, this probably generally appears when a common aggregated API was built at a time significantly before the +current Kubernetes version. The most common case is that the metrics server is built against an older version of the +Kubernetes libraries, using old versions of the structs. When the metrics server is updated to use the latest version of +the Kubernetes libraries, the problems go away, because the aggregated API and Kubernetes agree about the shape of the +struct. + +Using the first encountered definition is imperfect and could result in unreliable diffs. But it's better than +constructing completely-wrong diffs due to the lack of a GVKParser. +*/ + +// uniqueModels is a model provider that ensures that no two models share the same gvk. Use newUniqueModels to +// initialize it and enforce uniqueness. +type uniqueModels struct { + models map[string]proto.Schema +} + +// LookupModel is public through the interface of Models. It +// returns a visitable schema from the given model name. +// Copied verbatim from here: https://github.com/kubernetes/kube-openapi/blob/b456828f718bab62dc3013d192665eb3d17f8fe9/pkg/util/proto/document.go#L322-L326 +func (d *uniqueModels) LookupModel(model string) proto.Schema { + return d.models[model] +} + +// Copied verbatim from here: https://github.com/kubernetes/kube-openapi/blob/b456828f718bab62dc3013d192665eb3d17f8fe9/pkg/util/proto/document.go#L328-L337 +func (d *uniqueModels) ListModels() []string { + models := []string{} + + for model := range d.models { + models = append(models, model) + } + + sort.Strings(models) + return models +} + +// newUniqueModels returns a new uniqueModels instance and a list of warnings for models that share the same gvk. +func newUniqueModels(models proto.Models) (proto.Models, []schema.GroupVersionKind) { + var taintedGVKs []schema.GroupVersionKind + gvks := map[schema.GroupVersionKind]string{} + um := &uniqueModels{models: map[string]proto.Schema{}} + for _, modelName := range models.ListModels() { + model := models.LookupModel(modelName) + if model == nil { + panic(fmt.Sprintf("ListModels returns a model that can't be looked-up for: %v", modelName)) + } + gvkList := parseGroupVersionKind(model) + gvk, wasProcessed := modelGvkWasAlreadyProcessed(model, gvks) + if !wasProcessed { + um.models[modelName] = model + + // Add GVKs to the map, so we can detect a duplicate GVK later. + for _, gvk := range gvkList { + if len(gvk.Kind) > 0 { + gvks[gvk] = modelName + } + } + } else { + taintedGVKs = append(taintedGVKs, gvk) + } + } + return um, taintedGVKs +} + +// modelGvkWasAlreadyProcessed inspects a model to determine if it would trigger a duplicate GVK error. The gvks map +// holds the GVKs of all the models that have already been processed. If the model would trigger a duplicate GVK error, +// the function returns the GVK that would trigger the error and true. Otherwise, it returns an empty GVK and false. +func modelGvkWasAlreadyProcessed(model proto.Schema, gvks map[schema.GroupVersionKind]string) (schema.GroupVersionKind, bool) { + gvkList := parseGroupVersionKind(model) + // Not every model has a GVK extension specified. For those models, this loop will be skipped. + for _, gvk := range gvkList { + // The kind length check is copied from managedfields.NewGVKParser. It's unclear what edge case it's handling, + // but the behavior of this function should match NewGVKParser. + if len(gvk.Kind) > 0 { + _, ok := gvks[gvk] + if ok { + // This is the only condition under which NewGVKParser would return a duplicate GVK error. + return gvk, true + } + } + } + return schema.GroupVersionKind{}, false +} + +// groupVersionKindExtensionKey is the key used to lookup the +// GroupVersionKind value for an object definition from the +// definition's "extensions" map. +// Copied verbatim from: https://github.com/kubernetes/apimachinery/blob/eb26334eeb0f769be8f0c5665ff34713cfdec83e/pkg/util/managedfields/gvkparser.go#L29-L32 +const groupVersionKindExtensionKey = "x-kubernetes-group-version-kind" + +// parseGroupVersionKind gets and parses GroupVersionKind from the extension. Returns empty if it doesn't have one. +// Copied verbatim from: https://github.com/kubernetes/apimachinery/blob/eb26334eeb0f769be8f0c5665ff34713cfdec83e/pkg/util/managedfields/gvkparser.go#L82-L128 +func parseGroupVersionKind(s proto.Schema) []schema.GroupVersionKind { + extensions := s.GetExtensions() + + gvkListResult := []schema.GroupVersionKind{} + + // Get the extensions + gvkExtension, ok := extensions[groupVersionKindExtensionKey] + if !ok { + return []schema.GroupVersionKind{} + } + + // gvk extension must be a list of at least 1 element. + gvkList, ok := gvkExtension.([]any) + if !ok { + return []schema.GroupVersionKind{} + } + + for _, gvk := range gvkList { + // gvk extension list must be a map with group, version, and + // kind fields + gvkMap, ok := gvk.(map[any]any) + if !ok { + continue + } + group, ok := gvkMap["group"].(string) + if !ok { + continue + } + version, ok := gvkMap["version"].(string) + if !ok { + continue + } + kind, ok := gvkMap["kind"].(string) + if !ok { + continue + } + + gvkListResult = append(gvkListResult, schema.GroupVersionKind{ + Group: group, + Version: version, + Kind: kind, + }) + } + + return gvkListResult +} diff --git a/gitops-engine/pkg/utils/testing/testdata.go b/gitops-engine/pkg/utils/testing/testdata.go new file mode 100644 index 0000000000000..ad446fdfb863a --- /dev/null +++ b/gitops-engine/pkg/utils/testing/testdata.go @@ -0,0 +1,99 @@ +package testing + +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +const ( + FakeArgoCDNamespace = "fake-argocd-ns" +) + +func HelmHook(obj *unstructured.Unstructured, hookType string) *unstructured.Unstructured { + return Annotate(obj, "helm.sh/hook", hookType) +} + +func Annotate(obj *unstructured.Unstructured, key, val string) *unstructured.Unstructured { + annotations := obj.GetAnnotations() + if annotations == nil { + annotations = map[string]string{} + } + annotations[key] = val + obj.SetAnnotations(annotations) + return obj +} + +var PodManifest = ` +{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": { + "name": "my-pod" + }, + "spec": { + "containers": [ + { + "image": "nginx:1.7.9", + "name": "nginx", + "resources": { + "requests": { + "cpu": 0.2 + } + } + } + ] + } +} +` + +func NewPod() *unstructured.Unstructured { + return Unstructured(PodManifest) +} + +var ServiceManifest = ` +{ + "apiVersion": "v1", + "kind": "Service", + "metadata": { + "name": "my-service" + }, + "spec": { + "ports": [ + { + "name": "http", + "protocol": "TCP", + "port": 80, + "targetPort": 8080 + } + ], + "selector": { + "app": "my-service" + } + } +} +` + +func NewService() *unstructured.Unstructured { + return Unstructured(ServiceManifest) +} + +func NewCRD() *unstructured.Unstructured { + return Unstructured(`apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + name: testcrds.argoproj.io +spec: + group: argoproj.io + version: v1 + scope: Namespaced + names: + plural: testcrds + kind: TestCrd`) +} + +func NewNamespace() *unstructured.Unstructured { + return Unstructured(`apiVersion: v1 +kind: Namespace +metadata: + name: testnamespace +spec:`) +} diff --git a/gitops-engine/pkg/utils/testing/unstructured.go b/gitops-engine/pkg/utils/testing/unstructured.go new file mode 100644 index 0000000000000..f6c2920016228 --- /dev/null +++ b/gitops-engine/pkg/utils/testing/unstructured.go @@ -0,0 +1,32 @@ +package testing + +import ( + "encoding/json" + "os" + "strings" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "sigs.k8s.io/yaml" +) + +func UnstructuredFromFile(path string) *unstructured.Unstructured { + file, err := os.ReadFile(path) + if err != nil { + panic(err) + } + return Unstructured(string(file)) +} + +func Unstructured(text string) *unstructured.Unstructured { + un := &unstructured.Unstructured{} + var err error + if strings.HasPrefix(text, "{") { + err = json.Unmarshal([]byte(text), &un) + } else { + err = yaml.Unmarshal([]byte(text), &un) + } + if err != nil { + panic(err) + } + return un +} diff --git a/gitops-engine/pkg/utils/text/text.go b/gitops-engine/pkg/utils/text/text.go new file mode 100644 index 0000000000000..7c8f865a666e8 --- /dev/null +++ b/gitops-engine/pkg/utils/text/text.go @@ -0,0 +1,18 @@ +package text + +func FirstNonEmpty(args ...string) string { + for _, value := range args { + if len(value) > 0 { + return value + } + } + return "" +} + +// WithDefault return defaultValue when val is blank +func WithDefault(val string, defaultValue string) string { + if len(val) == 0 { + return defaultValue + } + return val +} diff --git a/gitops-engine/pkg/utils/tracing/api.go b/gitops-engine/pkg/utils/tracing/api.go new file mode 100644 index 0000000000000..89670a67b2558 --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/api.go @@ -0,0 +1,16 @@ +package tracing + +/* + Poor Mans OpenTracing. + + Standardizes logging of operation duration. +*/ + +type Tracer interface { + StartSpan(operationName string) Span +} + +type Span interface { + SetBaggageItem(key string, value any) + Finish() +} diff --git a/gitops-engine/pkg/utils/tracing/logging.go b/gitops-engine/pkg/utils/tracing/logging.go new file mode 100644 index 0000000000000..fd0619f9910b9 --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/logging.go @@ -0,0 +1,56 @@ +package tracing + +import ( + "time" + + "github.com/go-logr/logr" +) + +var ( + _ Tracer = LoggingTracer{} + _ Span = loggingSpan{} +) + +type LoggingTracer struct { + logger logr.Logger +} + +func NewLoggingTracer(logger logr.Logger) *LoggingTracer { + return &LoggingTracer{ + logger: logger, + } +} + +func (l LoggingTracer) StartSpan(operationName string) Span { + return loggingSpan{ + logger: l.logger, + operationName: operationName, + baggage: make(map[string]any), + start: time.Now(), + } +} + +type loggingSpan struct { + logger logr.Logger + operationName string + baggage map[string]any + start time.Time +} + +func (s loggingSpan) Finish() { + s.logger.WithValues(baggageToVals(s.baggage)...). + WithValues("operation_name", s.operationName, "time_ms", time.Since(s.start).Seconds()*1e3). + Info("Trace") +} + +func (s loggingSpan) SetBaggageItem(key string, value any) { + s.baggage[key] = value +} + +func baggageToVals(baggage map[string]any) []any { + result := make([]any, 0, len(baggage)*2) + for k, v := range baggage { + result = append(result, k, v) + } + return result +} diff --git a/gitops-engine/pkg/utils/tracing/logging_test.go b/gitops-engine/pkg/utils/tracing/logging_test.go new file mode 100644 index 0000000000000..f9346550f0dc0 --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/logging_test.go @@ -0,0 +1,28 @@ +package tracing + +import ( + "testing" + + "github.com/go-logr/logr" + "go.uber.org/mock/gomock" + + "github.com/argoproj/gitops-engine/pkg/utils/tracing/tracer_testing" +) + +func TestLoggingTracer(t *testing.T) { + c := gomock.NewController(t) + l := tracer_testing.NewMockLogSink(c) + gomock.InOrder( + l.EXPECT().Init(gomock.Any()), + l.EXPECT().WithValues("my-key", "my-value").Return(l), + l.EXPECT().WithValues("operation_name", "my-operation", "time_ms", gomock.Any()).Return(l), + l.EXPECT().Enabled(gomock.Any()).Return(true), + l.EXPECT().Info(0, "Trace"), + ) + + tr := NewLoggingTracer(logr.New(l)) + + span := tr.StartSpan("my-operation") + span.SetBaggageItem("my-key", "my-value") + span.Finish() +} diff --git a/gitops-engine/pkg/utils/tracing/nop.go b/gitops-engine/pkg/utils/tracing/nop.go new file mode 100644 index 0000000000000..e39b67b99f54f --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/nop.go @@ -0,0 +1,20 @@ +package tracing + +var ( + _ Tracer = NopTracer{} + _ Span = nopSpan{} +) + +type NopTracer struct{} + +func (n NopTracer) StartSpan(_ string) Span { + return nopSpan{} +} + +type nopSpan struct{} + +func (n nopSpan) SetBaggageItem(_ string, _ any) { +} + +func (n nopSpan) Finish() { +} diff --git a/gitops-engine/pkg/utils/tracing/tracer_testing/doc.go b/gitops-engine/pkg/utils/tracing/tracer_testing/doc.go new file mode 100644 index 0000000000000..645c2f4612e39 --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/tracer_testing/doc.go @@ -0,0 +1,3 @@ +package tracer_testing + +//go:generate go run go.uber.org/mock/mockgen -destination "logger.go" -package "tracer_testing" "github.com/go-logr/logr" "LogSink" diff --git a/gitops-engine/pkg/utils/tracing/tracer_testing/logger.go b/gitops-engine/pkg/utils/tracing/tracer_testing/logger.go new file mode 100644 index 0000000000000..2a5474b873858 --- /dev/null +++ b/gitops-engine/pkg/utils/tracing/tracer_testing/logger.go @@ -0,0 +1,133 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/go-logr/logr (interfaces: LogSink) +// +// Generated by this command: +// +// mockgen -destination logger.go -package tracer_testing github.com/go-logr/logr LogSink +// + +// Package tracer_testing is a generated GoMock package. +package tracer_testing + +import ( + reflect "reflect" + + logr "github.com/go-logr/logr" + gomock "go.uber.org/mock/gomock" +) + +// MockLogSink is a mock of LogSink interface. +type MockLogSink struct { + ctrl *gomock.Controller + recorder *MockLogSinkMockRecorder + isgomock struct{} +} + +// MockLogSinkMockRecorder is the mock recorder for MockLogSink. +type MockLogSinkMockRecorder struct { + mock *MockLogSink +} + +// NewMockLogSink creates a new mock instance. +func NewMockLogSink(ctrl *gomock.Controller) *MockLogSink { + mock := &MockLogSink{ctrl: ctrl} + mock.recorder = &MockLogSinkMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLogSink) EXPECT() *MockLogSinkMockRecorder { + return m.recorder +} + +// Enabled mocks base method. +func (m *MockLogSink) Enabled(level int) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Enabled", level) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Enabled indicates an expected call of Enabled. +func (mr *MockLogSinkMockRecorder) Enabled(level any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enabled", reflect.TypeOf((*MockLogSink)(nil).Enabled), level) +} + +// Error mocks base method. +func (m *MockLogSink) Error(err error, msg string, keysAndValues ...any) { + m.ctrl.T.Helper() + varargs := []any{err, msg} + for _, a := range keysAndValues { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Error", varargs...) +} + +// Error indicates an expected call of Error. +func (mr *MockLogSinkMockRecorder) Error(err, msg any, keysAndValues ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{err, msg}, keysAndValues...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogSink)(nil).Error), varargs...) +} + +// Info mocks base method. +func (m *MockLogSink) Info(level int, msg string, keysAndValues ...any) { + m.ctrl.T.Helper() + varargs := []any{level, msg} + for _, a := range keysAndValues { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Info", varargs...) +} + +// Info indicates an expected call of Info. +func (mr *MockLogSinkMockRecorder) Info(level, msg any, keysAndValues ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{level, msg}, keysAndValues...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogSink)(nil).Info), varargs...) +} + +// Init mocks base method. +func (m *MockLogSink) Init(info logr.RuntimeInfo) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Init", info) +} + +// Init indicates an expected call of Init. +func (mr *MockLogSinkMockRecorder) Init(info any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockLogSink)(nil).Init), info) +} + +// WithName mocks base method. +func (m *MockLogSink) WithName(name string) logr.LogSink { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WithName", name) + ret0, _ := ret[0].(logr.LogSink) + return ret0 +} + +// WithName indicates an expected call of WithName. +func (mr *MockLogSinkMockRecorder) WithName(name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithName", reflect.TypeOf((*MockLogSink)(nil).WithName), name) +} + +// WithValues mocks base method. +func (m *MockLogSink) WithValues(keysAndValues ...any) logr.LogSink { + m.ctrl.T.Helper() + varargs := []any{} + for _, a := range keysAndValues { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WithValues", varargs...) + ret0, _ := ret[0].(logr.LogSink) + return ret0 +} + +// WithValues indicates an expected call of WithValues. +func (mr *MockLogSinkMockRecorder) WithValues(keysAndValues ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithValues", reflect.TypeOf((*MockLogSink)(nil).WithValues), keysAndValues...) +} diff --git a/gitops-engine/specs/deployment-repo-update.md b/gitops-engine/specs/deployment-repo-update.md new file mode 100644 index 0000000000000..0e07f37e27d7d --- /dev/null +++ b/gitops-engine/specs/deployment-repo-update.md @@ -0,0 +1,34 @@ +# Deployment Repo Update Automation + +## Summary + +The GitOps driven continuous deployment cycle starts with a change in the Git repository that contains resource manifests. Flux provides the +[Automated Image Update](https://docs.fluxcd.io/en/latest/references/automated-image-update.html) feature that continuously monitors the docker registry and automatically +updates deployment repo when a new image is released. This functionality is not available for Argo CD users. Also, some Argo CD users need only functionality related to the +Git repository updating and don't need docker registry monitoring. + +This document is meant to collect requirements for the Git repository update functionality. As a next step, we could discuss if it is possible to implement a Golang library or +a service that can be used in combination with Argo CD and Flux. + +> Note: Flux already plans to split out the docker registry monitor and image updating feature into a separate component. We should consider re-using the extracted component. + +## Requirements + +### Manifests updating + +When updates are discovered for any image referenced in resource manifests in the configuration repository, new manifests that refer to the updated image tags/versions must be generated. +The manifests might be stored as raw YAML files or as the templating tool package such as Kustomize or Helm. The manifest updating functionality should take new images +set as an input and update manifest files or templating tool configs to use the provided set of images. + +### Commit signing + +The user might want to use GPG signing for each commit in the deployment repo. The commit signing feature should allow to optionally +sign the commit with the image changes. + +### Interaction with Git + +The feature provides the following basic functionalities: +* Clone Git repo or update the local copy of a previously cloned copy +* Configure local Git user name and email. +* Push changes back to Git remote repo. +* Rebase remote changes in case of concurrent repository update. diff --git a/gitops-engine/specs/design-bottom-up.md b/gitops-engine/specs/design-bottom-up.md new file mode 100644 index 0000000000000..fffd34d226d9e --- /dev/null +++ b/gitops-engine/specs/design-bottom-up.md @@ -0,0 +1,207 @@ +# GitOps Engine Design - Bottom Up [On Hold - see [Top Down](./design-top-down.md)] + +## Summary + +The Bottom Up approach assumes that teams identify similar components in Argo CD and Flux and merge them one by one. The following five components were identified so far: + +* Access to Git repositories +* Kubernetes resource cache +* Manifest Generation +* Resources reconciliation +* Sync Planning + +The rest of the document describes separate proposals of how exactly components could be merged. + +## Kubernetes Resource Cache + +Both Argo CD and Flux have to load target cluster resources. This is required to enable the following main use cases: +- Collect resources that are no longer in Git and delete/warn the user. +- Present information about cluster state to the user: Argo CD UI, fluxctl `list-images`, `list-workloads` commands. +- Compare the state of the cluster with the configuration in Git. + +Projects use different approaches to collect cluster state information. Argo CD leverages Kubernetes watch APIs to maintain +lightweight cluster state cache. Flux fetches required resources when information is needed. + +The problem is that Kubernetes does not provide an SQL like API which allows to effectively find required resources and in +some cases, Flux has to load whole cluster/namespace state into memory and go through the in-memory resources list. This is +a time and memory consuming approach, which also puts pressure on Kubernetes' API server. + +### Goals + +Extract Argo CD caching logic into a reusable component that maintains a lightweight cluster state cache. argoproj/argo-cd/controller/cache + +### Non-Goals +Support multi-cluster caching. The ability to maintain a cache of multiple-cluster is implemented in Argo CD code but it is tightly coupled +to how Argo CD stores cluster credentials and add too much complexity. + +### Proposal. + +The cluster cache component encapsulates interaction with Kubernetes APIs and allows to quickly inspect Kubernetes resources in a thread-safe +manner. The component is responsible for the following tasks: + +- Identify resource APIs supported by the target cluster and provide API’s metadata (e.g. if API is namespaced or cluster scope). +- Notifying about changes in the resource APIs supported by the target cluster (e.g. added CRDs, removed CRDs ...). +- Loads initial state and watch for changes in every supported resource API. +- Handles available changes APIs: start/stops watches; removes obsolete APIs from the cache. + +The component does not cache the whole resource manifest because it would require too much memory. Instead, it stores only +resource identifiers and relationships between resources. The whole resource manifest or any other resource metadata should +be cached by the component user using event handlers. + +The component watches only the preferred version of each resource API. So resource object passed to the event handlers has the +structure of the preferred version. + +The component is responsible for the handling of following Kubernetes API edge cases: + +Resources of the deprecated extensions API group have duplicates in groups apps, networking.k8s.io, policy. +* The ReplicaSet from apps group might reference Deployment from the extensions group as a parent. +* The relationship between Service and Endpoint is not explicit: [kubernetes/#28483](https://github.com/kubernetes/kubernetes/issues/28483) +* The relationship between ServiceAccount and Token is not explicit. +* Resources of OpenShift deprecated groups authorization.openshift.io and project.openshift.io create +duplicates in rbac.authorization.k8s.io and core groups. + +#### Top-Level Component APIs + +The listing below represents top-level API exposed by cluster cache component: + +```golang +// ResourceID is a unique resource identifier. +type ResourceID struct { + // Namespace is empty for cluster-scoped resources. + Namespace string + Name string + Group string + Kind string +} + +type ListOptions struct { + // A selector to restrict the list of returned objects by their labels. + Selector metav1.LabelSelector + // Restricts list of returned objects by namespace. If not empty the only namespaced resources are returned. + Namespaces []string + // If set to true then only namespaced object are returned. + NamespacedOnly bool + // If set to true then only cluster level object are returned. + ClusterLevelOnly bool + // If set to true then only objects without owners are returned. + TopLevelOnly bool +} + +// Cache provides a set of methods to access the cached cluster's state. All methods are thread safe. +type Cache interface { + // List returns a list of resource ids which match the specified list options + List(options ListOptions) ([]ResourceID, error) + // GetResourceAPIMetadata returns API ( metav1.APIResource includes information about supported verb, namespaced/cluster level etc) + GetResourceAPIMetadata(gk schema.GroupKind) (metav1.APIResource, error) + // IterateChildTree builds a DAG using parent-child relationships based on ownerReferences resource field and + // traverse resources in a topological order starting from specified root ids + IterateChildTree(roots []ResourceID, action func(key ResourceID) error) error +} +``` + +The Cache interface methods are serving following use cases: + +List: +* Returns resources managed by Argo CD/Flux. Typically top-level resources labeled with a special label. +* Returns orphaned namespace resources. This will enable the Argo CD feature of warning the user if a namespace has any unmanaged resources. + +GetResourceAPIMetadata: +* Answers whether a resource namespace-scoped or cluster-scoped. This is useful in two cases: + * to gracefully handle user errors when cluster-level resource Git have namespace. This is incorrect, but kubectl gracefully handles such errors. + * set fallback namespace to namespaced resources without namespace +* Helps to create a dynamic K8s client and specify the resource/kind. + +IterateChildTree: +* The method allows Argo CD to get information about resources tree which is used to visualize cluster state in the UI + +#### Customizations +The listing below contains a set of data structures that allows customizing caching behavior. + +```golang +type ResourceFilter struct { + APIGroups []string + Kinds []string +} + +type ResourcesAPIFilter struct { + // ResourceExclusions holds the api groups, kinds which should be excluded + ResourceExclusions []ResourceFilter + // ResourceInclusions holds the only api groups that should be included. Assumes that everything is included in empty. + ResourceInclusions []ResourceFilter +} + +// ResourceEventHandlers is a set of handlers which are executed when resources updated/created/deleted. +type ResourceEventHandlers struct { + OnCreated func(obj *unstructured.Unstructured) + OnUpdated func(updated *unstructured.Unstructured) + OnDeleted func(key ResourceID) +} + +// Settings contains list of parameters which customize caching behavior +type Settings struct { + Filter ResourcesAPIFilter + EventHandlers ResourceEventHandlers + Namespaces []string + ResyncPeriod time.Duration +} + +func NewClusterCache(config *rest.Config, settings Settings) (Cache, error) +``` + +ResourceEventHandlers: +A set of callbacks that are executed when cache changes. Useful to collect and cache additional information about resources, for example: +* Cache whole manifest of a managed resource to use it later for reconciliation +* Cache resource metadata such as a list of images or health status. + +ResourceAPIFilter: +Enables limiting the set of monitored resource APIs. + +Namespaces: +Allows switching component into namespace only mode. If one or more namespaces are specified then component ignore cluster level resources and watch only resources in the specified namespaces. + +NOTE: Kubernetes API allows to list/watch resources only in one namespace or the whole cluster. So if more than one namespace is specified then component have to start separate set of watches for each namespace. + +ResyncPeriod: +Specifies interval after which cluster cache should be automatically invalidated. + +#### Health Assessment (optionally) + +The health assessment subcomponent provides the ability to get health information about a given resource. The health assessment package is not directly related to caching but helps to leverage functionality provided by caching and thus its proposed for inclusion into the caching component.. + +The health assessment logic is available in package argoproj/argo-cd/util/health and includes the following features: +* Support for several Kubernetes built-in resources such as Pod, ReplicaSet, Pod, Ingress and few others +* A framework that allows customizing health assessment logic using Lua script. Framework includes testing infrastructure. + +The health information is represented by the following data structure: + +```golang +type HealthStatus struct { + Status HealthStatusCode + Message string +} +``` + +The health status might take one of the following values: +* Healthy/Degraded - self explanatory +* Progressing - the resource is not healthy yet but there is still a chance to become Healthy. +* Unknown - the health assessment failed. The error message is in the `Message` field. +* Suspended - the resource is neither progressing nor degraded. For example Deployment is considered suspended if `spec.paused` field is set to true. +* Missing - the expected resource is missing + +The library API is represented by a single method: + +```golang +type HealthAssessor interface { + GetResourceHealth(obj *unstructured.Unstructured) (*HealthStatus, error) +} +``` + +#### Additional Considerations + +The live state cache could be useful for the docker-registry monitoring feature: the `OnUpdated` resource event handler can be used to maintain a images pull secrets. However, if the docker registry part is extracted into a separate binary we would have to run a separate instance of a cluster cache which means 2x more Kubernetes API calls. The workaround would be to optionally point Docker Registry Monitor to Flux? + +## Reconciliation [WIP] +## Access to Git repositories [WIP] +## Manifest Generation [WIP] +## Resources reconciliation [WIP] +## Sync Planning [WIP] diff --git a/gitops-engine/specs/design-top-down.md b/gitops-engine/specs/design-top-down.md new file mode 100644 index 0000000000000..335fde1cb61a4 --- /dev/null +++ b/gitops-engine/specs/design-top-down.md @@ -0,0 +1,227 @@ +# GitOps Engine Design - Top Down [WIP] + +## Summary + +During the elaboration of [Bottom Up](./design-bottom-up.md) option, we've discovered that this +approach is challenging. Although components are similar at a high-level there is +still a lot of differences in design and implementation, so it is hard to re-use either of them in +both projects without redesign. This is not surprising because code was developed +by different teams and with a focus on different use-cases. To speed-up the process it is +proposed to take a whole sub-system of one project and make it customizable enough to +be suitable for both Argo CD and Flux. + +## Proposal + +It is proposed to extract of Argo CD application controller subsystem, that is responsible for +interacting with Kubernetes and resources reconciliation and syncing. The sub-system should be refactored +and used in both Argo CD and Flux. During refactoring we should make sure that it supports all +customizations that are required to keep Flux behavior untouched.There are two main reasons to try using +Argo CD as a base for reconciliation engine: +- Argo CD uses the _Application_ abstraction to represent the desired state and target the Kubernetes cluster. +This abstraction works for both Argo CD and Flux. +- The Argo CD controller leverages Kubernetes watch APIs instead of polling. This enables Argo CD features +such as Health assessment, UI and could provide better performance to Flux as well. + +### Manifest Generation + +The manifest generation logic is very different in Argo CD and Flux: Argo CD focuses on providing first class +support for existing config management tools while Flux provides a flexible way to connect any config +management tool using .flux.yaml files. I think we should merge manifest generation step by step, after core +of GitOps engine is established. + +### Repository Access + +Flux has much more Git related features than Argo CD. I think we might do the same exercise as a next step: +generalize Flux's Git access, commit verification, write back features and contribute to the engine as +a whole sub-system. + +### Hypothesis and assumptions + +The proposed solution is based on the assumption that despite implementation differences the core functionality of Argo CD and Flux behaves in the same way. Both projects +ultimately extract the set of manifests from Git and use "kubectl apply" to change the cluster state. The minor differences are expected but we can resolve them by introducing new +knobs. + +Also, the proposed approach is based on the assumption that Argo CD engine is flexible enough to cover all Flux use-cases, reproduce Flux's behavior with minor differences and can +be easily integrated into Argo CD. + +However, there is a risk that there will be too many differences and it might be not feasible to support all of them. To get early feedback, we will start with a Proof-of-Concept +(PoC from now on) implementation which will serve as an experiment to assess the feasibility of the approach. + +### Acceptance criteria + +To consider the PoC successful (and with the exception of features excluded from the PoC to save time), +all the following must hold true: +1. All the Flux unit and end-to-end tests must pass. The existing tests are limited, so we may decide to +include additional ones. +2. The UX of Flux must remain unchanged. That includes: + - The flags of `fluxd` and `fluxctl` must be respected and can be used in the same way as before + resulting in the same configuration behavioural changes. + - Flux's API must remain unchanged. In particular, the web API (used by fluxctl) and the websocket API (e.g. used to + communicate with Weave Cloud) must work without changes. +3. Flux's writing behaviour on Git and Kubernetes must be identical. In particular: + - Flux+GitEngine should make changes in Git if and only if Flux without GitEngine would had done it, + in the same way (same content) and in the same situations + - Flux+GitEngine should add and update Kubernetes resources if and only if Flux without GitEngine would had done, + in the same way (same content) and in the same situations + +Unfortunately, there isn't a straightforward way to decidedly check for (3). + +Additionally, there must be a clear way forward (in the shape of well-defined steps) +for the features not covered by the PoC to work (complying with the points above) int he final GitOps +Engine. + +### GitOps Engine PoC + +The PoC deliverables are: + +- All PoC changes are in separate branches. +- Argo CD controller will be moved to https://github.com/argoproj/gitops-engine. +- Flux will import GitOps engine component from the https://github.com/argoproj/gitops-engine repository and use it to perform cluster state syncing. +- The flux installation and fluxctl behavior will remain the same other than using GitOps engine internally. That means there will be no creation of Application CRD or Argo CD +specific ConfigMaps/Secrets. +- For the sake of saving time POC does not include implementing features mentioned before. So no commit verification, only plain .yaml files support, and full cluster mode. + +## Design Details + +The proposed design is based on the PoC that contains draft implementation and provides the base idea of a target design. PoC is available in +[argo-cd#fargo/engine](https://github.com/alexmt/argo-cd/tree/fargo/engine) and [flux#fargo](https://github.com/alexmt/flux/tree/fargo) + +The GitOps engine API consists of three main packages: +* The `utils` package. It consist of loosely coupled packages that implements K8S resource diffing, health assessment, etc +* The `sync` package that contains Sync data structure definition and CRUD client interface. +* The `engine` package that leverages `utils` and uses provided set of Applications as a configuration source. + +``` +gitops-engine +|-- pkg +| |-- utils +| | |-- diff # provides Kubernetes resource diffing functionality +| | |-- kube # provides utility methods to interact with Kubernetes +| | |-- lua # provides utility methods to run Lua scripts +| | |-- sync # provides utility methods to manipulate Sync (e.g. start sync operation, wait for sync operation, force reconciliation) +| | `-- health # provides Kubernetes resources health assessment +| |-- sync +| | |-- apis # contains data structures that describe Sync +| | `-- client # contains client that provides Sync CRUD operations +| `-- engine # the engine implementation +``` + +The engine is responsible for the reconciliation of Kubernetes resources, which includes: +- Interacting with the Kubernetes API: load and maintain the cluster state; pushing required changes to the Kubernetes API. +- Reconciliation logic: match target K8S cluster resources with the resources stored in Git and decide which resources should be updated/deleted/created. +- Syncing logic: determine the order in which resources should be modified; features like sync hooks, waves, etc. + +The manifests generation is out of scope and should be implemented by the Engine consumer. + +### Engine API + +> `Sync` is a place holder to a real name. The name is still under discussion + +The engine API includes three main parts: +- `Engine` golang interface +- `Sync` data structure and `SyncStore` interface which provides access to the units. +- Set of data structures which allows configuring reconciliation process. + +**Engine interface** - provides set of features that allows updating reconciliation settings and subscribe to engine events. +```golang +type Engine interface { + // Run starts reconciliation loop using specified number of processors for reconciliation and operation execution. + Run(ctx context.Context, statusProcessors int, operationProcessors int) + + // SetReconciliationSettings updates reconciliation settings + SetReconciliationSettings(settings ReconciliationSettings) + + // OnBeforeSync registers callback that is executed before each sync operation. + OnBeforeSync(callback func(appName string, tasks []SyncTaskInfo) ([]SyncTaskInfo, error)) Unsubscribe + + // OnSyncCompleted registers callback that is executed after each sync operation. + OnSyncCompleted(callback func(appName string, state OperationState) error) Unsubscribe + + // OnClusterCacheInitialized registers a callback that is executed when cluster cache initialization is completed. + // Callback is useful to wait until cluster cache is fully initialized before starting to use cached data. + OnClusterCacheInitialized(callback func(server string)) Unsubscribe + + // OnResourceUpdated registers a callback that is executed when cluster resource got updated. + OnResourceUpdated(callback func(cluster string, un *unstructured.Unstructured)) Unsubscribe + + // OnResourceRemoved registers a callback that is executed when a cluster resource gets removed. + OnResourceRemoved(callback func(cluster string, key kube.ResourceKey)) Unsubscribe + + // OnEvent registers callback that is executed on every sync event. + OnEvent(callback func(id string, info EventInfo, message string)) Unsubscribe +} + +type Unsubscribe func() +``` + +**Sync data structure** - allows engine accessing sync and update status. + +```golang +type Sync struct { + ID string + Status Status + Source ManifestSource + Destination ManifestDestination + Operation *Operation +} + +type SyncStore interface { + List() ([]Sync, error) + Get(id string) (Sync, error) + SetStatus(id string, status Status) (Sync, error) + SetOperation(id string, operation *Operation) error +} +``` + +**Settings data structures** - holds reconciliation settings and cluster credentials. +```golang +type ReconciliationSettings struct { + // AppInstanceLabelKey holds label key which is automatically added to every resource managed by the application + AppInstanceLabelKey string + // ResourcesFilter holds settings which allows to configure list of managed resource APIs + ResourcesFilter resource.ResourcesFilter + // ResourceOverrides holds settings which customize resource diffing logic + ResourceOverrides map[scheme.GroupKind]appv1.ResourceOverride +} + +// provides access to cluster credentials +type CredentialsStore interface { + GetCluster(ctx context.Context, name string) (*appv1.Cluster, error) + WatchClusters(ctx context.Context, callback func(event *ClusterEvent)) error +} +``` + +**ManifestGenerator** a Golang interface that must be implemented by the GitOps engine consumer. +```golang +type ManifestResponse struct { + // Generated manifests + Manifests []string + // Resolved Git revision + Revision string +} + +type ManifestGenerator interface { + Generate(ctx context.Context, app *appv1.Application, revision string, noCache bool) (*ManifestResponse, error) +} +``` + +**Engine instantiation** in order to create engine the consumer must provide the cluster credentials store and manifest generator as well as reconciliation settings. +The code snippets below contains `NewEngine` function definition and usage example: + +```golang +func NewEngine(settings ReconciliationSettings, creds CredentialsStore, manifests ManifestGenerator) +``` + +```golang +myManifests := manifests{} +myClusters := clusters{} +engine := NewEngine(ReconciliationSettings{}, myManifests, myClusters) +engine.OnBeforeSync(func(appName string, tasks []SyncTaskInfo) ([]SyncTaskInfo, error) { + // customize syncing process by returning update list of sync tasks or fail to prevent syncing + return tasks, nil +}) +``` + +## Alternatives + +[Bottom-up](./design-bottom-up.md) diff --git a/gitops-engine/specs/design.md b/gitops-engine/specs/design.md new file mode 100644 index 0000000000000..13743615e6cd1 --- /dev/null +++ b/gitops-engine/specs/design.md @@ -0,0 +1,29 @@ +# GitOps Engine Design + +## Summary + +Flux and ArgoCD are two popular open-source GitOps implementations. They currently offer different user experiences but, at their core, Flux and ArgoCD have a lot in common. +Therefore, the Flux and ArgoCD maintainers have decided to join forces, with the hypothesis that working on a single project will be more effective, avoiding duplicate work and +ultimately bringing more and better value to the end-user. + +Effectively merging Flux and ArgoCD into a single solution is a long term goal. As a first step, both the ArgoCD and Flux teams are going to work on designing and implementing +the GitOps Engine. + +![](https://user-images.githubusercontent.com/426437/66851601-ea9a6880-ef2f-11e9-807d-0c5f09fcc384.png) + +The maintenance and support of the GitOps Engine will be a joined effort by the Flux and ArgoCD teams. + +## Goals + +The GitOps Engine: +* should contain core functionality pre-existing in ArgoCD and Flux. + +## Non-Goals + +* is not intended as a general framework for implementing GitOps services. + +## Proposals + +Teams have considered two ways to extract common functionality into the GitOps engine: +1. [Bottom-up](./design-bottom-up.md). Identify components that are used in both projects and move them one by one into GitOps engine repository. +1. [Top-down](./design-top-down.md). Take a whole sub-system of one project and make it customizable enough to be suitable for both Argo CD and Flux. diff --git a/gitops-engine/specs/image-update-monitoring.md b/gitops-engine/specs/image-update-monitoring.md new file mode 100644 index 0000000000000..25d396a0d787a --- /dev/null +++ b/gitops-engine/specs/image-update-monitoring.md @@ -0,0 +1,31 @@ +# Docker Image Update Monitoring + +## Summary + +Many GitOps users would like to automate Kubernetes manifest changes in the deployment repository +(see [Deployment Repo Update Automation](./deployment-repo-update.md)). The changes might be triggered by +the CI pipeline run or a new image in the Docker registry. Flux provides docker registry monitoring as part of +[Automated Image Update](https://docs.fluxcd.io/en/latest/references/automated-image-update.html) feature. + +This document is meant to collect requirements for a component that provides docker registry monitoring functionality and +can be used by Argo CD and potentially Flux users. + +## Requirements + +### Configurable Event Handler + +When a new docker image is discovered the component should execute an event handler and pass the docker image name/version as a parameter. +The event handler is a shell script. The user should be able to specify the handler in the component configuration. + +### Docker Registry WebHooks + +Some Docker Registries send a webhook when a new image gets pushed. The component should provide a webhook handler which when invokes an event handler. + +### Image Pulling + +In addition to the webhook, the component should support images metadata pulling. The pulling should detect the new images and invoke an event handler for each new image. + +### Image Credentials Auto-Discovering + +If a component is running inside of a Kubernetes cluster together with the deployments then it already has access to the Docker registry credentials. Auto-Discovering functionality +detect available docker registry credentials and use them to access registries instead of requiring users to configure credentials manually. diff --git a/gitops-engine/specs/template.md b/gitops-engine/specs/template.md new file mode 100644 index 0000000000000..c61fc3d9bcc2a --- /dev/null +++ b/gitops-engine/specs/template.md @@ -0,0 +1,87 @@ + +# Title + +This is the title of the spec. Keep it simple and descriptive. A good title +can help communicate what the spec is and should be considered as part of any +review. + +The title should be lowercased and spaces/punctuation should be replaced with +`-`. + +## Summary + +The `Summary` section is incredibly important for producing high quality +user-focused documentation such as release notes or a development roadmap. It +should be possible to collect this information before implementation begins in +order to avoid requiring implementers to split their attention between writing +release notes and implementing the feature itself. Ensure that the tone and +content of the `Summary` section is useful for a wide audience. + +A good summary is probably at least a paragraph in length. + +## Goals + +List the specific goals of the spec. How will we know that this has succeeded? + +## Non-Goals + +What is out of scope for this spec? Listing non-goals helps to focus +discussion and make progress. + +## Proposal + +This is where we get down to the nitty gritty of what the proposal actually is. + +### User Stories [optional] + +Detail the things that people will be able to do if this spec is implemented. +Include as much detail as possible so that people can understand the "how" of +the system. The goal here is to make this feel real for users without getting +bogged down. + +#### Story 1 + +#### Story 2 + +### Implementation Details/Notes/Constraints [optional] + +What are the caveats to the implementation? What are some important details +that didn't come across above. Go in to as much detail as necessary here. +This might be a good place to talk about core concepts and how they relate. + +### Risks and Mitigations + +What are the risks of this proposal and how do we mitigate. Think broadly. +For example, consider both security and how this will impact the larger +kubernetes ecosystem. + +How will security be reviewed and by whom? How will UX be reviewed and by +whom? + +Consider including folks that also work outside the SIG or subproject. + +## Design Details + +### Upgrade / Downgrade / Migration Strategy + +If applicable, how will the component be upgraded and downgraded? Does this +spec propose migrating users from one component or behaviour to another? + +### Public API changes + +Does the spec propose a public API-facing change? If so, describe the impact of +changes. + +## Drawbacks [optional] + +Why should this spec _not_ be implemented. + +## Alternatives [optional] + +Similar to the `Drawbacks` section the `Alternatives` section is used to +highlight and record other possible approaches to delivering the value proposed +by the spec. diff --git a/go.work b/go.work new file mode 100644 index 0000000000000..951cc72f29ff6 --- /dev/null +++ b/go.work @@ -0,0 +1,6 @@ +go 1.25.0 + +use ( + . + ./gitops-engine +) diff --git a/go.work.sum b/go.work.sum new file mode 100644 index 0000000000000..a17f067dfeca9 --- /dev/null +++ b/go.work.sum @@ -0,0 +1,6 @@ +cloud.google.com/go v0.112.2 h1:ZaGT6LiG7dBzi6zNOvVZwacaXlmf3lRqnC4DQzqyRQw= +cloud.google.com/go/compute v1.24.0 h1:phWcR2eWzRJaL/kOiJwfFsPs4BaKq1j6vnpZrc1YlVg= +github.com/cenkalti/backoff v2.1.1+incompatible h1:tKJnvO2kl0zmb/jA5UKAt4VoEVw1qxKWjE/Bpp46npY= +github.com/coreos/go-oidc v2.3.0+incompatible h1:+5vEsrgprdLjjQ9FzIKAzQz1wwPD+83hQRfUIPh7rO0= +github.com/grpc-ecosystem/go-grpc-middleware v1.2.2 h1:FlFbCRLd5Jr4iYXZufAvgWN6Ao0JrI5chLINnUXDDr0= +github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= diff --git a/hack/generate-proto.sh b/hack/generate-proto.sh index 6ef90dcf3b5b1..fb83416c90a98 100755 --- a/hack/generate-proto.sh +++ b/hack/generate-proto.sh @@ -77,7 +77,7 @@ go-to-protobuf \ --output-dir="${GOPATH}/src/" # go-to-protobuf modifies vendored code. Re-vendor code so it's available for subsequent steps. -go mod vendor +go work vendor # Either protoc-gen-go, protoc-gen-gofast, or protoc-gen-gogofast can be used to build # server/*/.pb.go from .proto files. golang/protobuf and gogo/protobuf can be used diff --git a/prepare.sh b/prepare.sh new file mode 100755 index 0000000000000..37659eca6d2bf --- /dev/null +++ b/prepare.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +mkdir dir1 +# Move all files and directories except dir1 and prepare.sh +for item in *; do + if [[ "$item" != "dir1" && "$item" != "prepare.sh" ]]; then + mv "$item" dir1/ + fi +done +git rm -r pkg specs agent internal go.* Dockerfile LICENSE OWNERS README.md docs hack codecov.yml sonar-project.properties .github/ .golangci.yaml .gitignore +rm dir1/sonar-project.properties dir1/codecov.yml +mv dir1/ gitops-engine +git checkout -b migrate +git add gitops-engine +git add prepare.sh +git commit --signoff -m "prepare repo for migration to ArgoCD repo"